You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by pa...@apache.org on 2023/03/01 10:51:58 UTC
[shardingsphere] branch master updated: Use AutoMockExtension on frontend proxy modules part2 (#24407)
This is an automated email from the ASF dual-hosted git repository.
panjuan 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 d3a0417dc71 Use AutoMockExtension on frontend proxy modules part2 (#24407)
d3a0417dc71 is described below
commit d3a0417dc71d0ebf52eb0599192cda4019435b0d
Author: Liang Zhang <zh...@apache.org>
AuthorDate: Wed Mar 1 18:51:45 2023 +0800
Use AutoMockExtension on frontend proxy modules part2 (#24407)
---
.../transaction/BackendTransactionManagerTest.java | 125 +++++++++------------
.../impl/UnicastDatabaseBackendHandlerTest.java | 49 ++++----
.../database/DropDatabaseBackendHandlerTest.java | 57 +++++-----
.../distsql/DistSQLBackendHandlerFactoryTest.java | 58 +++++-----
.../ral/QueryableRALBackendHandlerTest.java | 24 ++--
.../ral/updatable/ImportMetaDataUpdaterTest.java | 55 +++++----
.../updatable/RefreshTableMetaDataUpdaterTest.java | 80 ++++++-------
.../transaction/TransactionBackendHandlerTest.java | 15 +--
.../backend/session/ConnectionSessionTest.java | 48 ++++----
9 files changed, 234 insertions(+), 277 deletions(-)
diff --git a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/connector/jdbc/transaction/BackendTransactionManagerTest.java b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/connector/jdbc/transaction/BackendTransactionManagerTest.java
index c2728a46203..12cf6ac154f 100644
--- a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/connector/jdbc/transaction/BackendTransactionManagerTest.java
+++ b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/connector/jdbc/transaction/BackendTransactionManagerTest.java
@@ -26,29 +26,32 @@ import org.apache.shardingsphere.proxy.backend.connector.BackendConnection;
import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
import org.apache.shardingsphere.proxy.backend.session.ConnectionSession;
import org.apache.shardingsphere.proxy.backend.session.transaction.TransactionStatus;
+import org.apache.shardingsphere.test.mock.AutoMockExtension;
+import org.apache.shardingsphere.test.mock.StaticMockSettings;
import org.apache.shardingsphere.transaction.ShardingSphereTransactionManagerEngine;
import org.apache.shardingsphere.transaction.api.TransactionType;
import org.apache.shardingsphere.transaction.rule.TransactionRule;
import org.apache.shardingsphere.transaction.spi.ShardingSphereTransactionManager;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
-import org.mockito.MockedStatic;
import org.mockito.internal.configuration.plugins.Plugins;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
import java.sql.SQLException;
import java.util.Collections;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.mockStatic;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-@RunWith(MockitoJUnitRunner.class)
+@ExtendWith(AutoMockExtension.class)
+@StaticMockSettings(ProxyContext.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
public final class BackendTransactionManagerTest {
@Mock
@@ -68,7 +71,7 @@ public final class BackendTransactionManagerTest {
private BackendTransactionManager backendTransactionManager;
- @Before
+ @BeforeEach
public void setUp() {
when(connectionSession.getTransactionStatus()).thenReturn(transactionStatus);
when(backendConnection.getConnectionSession()).thenReturn(connectionSession);
@@ -81,102 +84,86 @@ public final class BackendTransactionManagerTest {
@Test
public void assertBeginForLocalTransaction() {
ContextManager contextManager = mockContextManager();
- try (MockedStatic<ProxyContext> proxyContext = mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
- proxyContext.when(() -> ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
- newBackendTransactionManager(TransactionType.LOCAL, false);
- backendTransactionManager.begin();
- verify(transactionStatus).setInTransaction(true);
- verify(backendConnection).closeHandlers(true);
- verify(backendConnection).closeConnections(false);
- verify(localTransactionManager).begin();
- }
+ when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ newBackendTransactionManager(TransactionType.LOCAL, false);
+ backendTransactionManager.begin();
+ verify(transactionStatus).setInTransaction(true);
+ verify(backendConnection).closeHandlers(true);
+ verify(backendConnection).closeConnections(false);
+ verify(localTransactionManager).begin();
}
@Test
public void assertBeginForDistributedTransaction() {
ContextManager contextManager = mockContextManager();
- try (MockedStatic<ProxyContext> proxyContext = mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
- proxyContext.when(() -> ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
- newBackendTransactionManager(TransactionType.XA, true);
- backendTransactionManager.begin();
- verify(transactionStatus, times(0)).setInTransaction(true);
- verify(backendConnection, times(0)).closeConnections(false);
- verify(shardingSphereTransactionManager).begin();
- }
+ when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ newBackendTransactionManager(TransactionType.XA, true);
+ backendTransactionManager.begin();
+ verify(transactionStatus, times(0)).setInTransaction(true);
+ verify(backendConnection, times(0)).closeConnections(false);
+ verify(shardingSphereTransactionManager).begin();
}
@Test
public void assertCommitForLocalTransaction() throws SQLException {
ContextManager contextManager = mockContextManager();
- try (MockedStatic<ProxyContext> proxyContext = mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
- proxyContext.when(() -> ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
- newBackendTransactionManager(TransactionType.LOCAL, true);
- backendTransactionManager.commit();
- verify(transactionStatus).setInTransaction(false);
- verify(localTransactionManager).commit();
- }
+ when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ newBackendTransactionManager(TransactionType.LOCAL, true);
+ backendTransactionManager.commit();
+ verify(transactionStatus).setInTransaction(false);
+ verify(localTransactionManager).commit();
}
@Test
public void assertCommitForDistributedTransaction() throws SQLException {
ContextManager contextManager = mockContextManager();
- try (MockedStatic<ProxyContext> proxyContext = mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
- proxyContext.when(() -> ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
- newBackendTransactionManager(TransactionType.XA, true);
- backendTransactionManager.commit();
- verify(transactionStatus).setInTransaction(false);
- verify(shardingSphereTransactionManager).commit(false);
- }
+ when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ newBackendTransactionManager(TransactionType.XA, true);
+ backendTransactionManager.commit();
+ verify(transactionStatus).setInTransaction(false);
+ verify(shardingSphereTransactionManager).commit(false);
}
@Test
public void assertCommitWithoutTransaction() throws SQLException {
ContextManager contextManager = mockContextManager();
- try (MockedStatic<ProxyContext> proxyContext = mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
- proxyContext.when(() -> ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
- newBackendTransactionManager(TransactionType.LOCAL, false);
- backendTransactionManager.commit();
- verify(transactionStatus, times(0)).setInTransaction(false);
- verify(localTransactionManager, times(0)).commit();
- verify(shardingSphereTransactionManager, times(0)).commit(false);
- }
+ when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ newBackendTransactionManager(TransactionType.LOCAL, false);
+ backendTransactionManager.commit();
+ verify(transactionStatus, times(0)).setInTransaction(false);
+ verify(localTransactionManager, times(0)).commit();
+ verify(shardingSphereTransactionManager, times(0)).commit(false);
}
@Test
public void assertRollbackForLocalTransaction() throws SQLException {
ContextManager contextManager = mockContextManager();
- try (MockedStatic<ProxyContext> proxyContext = mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
- proxyContext.when(() -> ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
- newBackendTransactionManager(TransactionType.LOCAL, true);
- backendTransactionManager.rollback();
- verify(transactionStatus).setInTransaction(false);
- verify(localTransactionManager).rollback();
- }
+ when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ newBackendTransactionManager(TransactionType.LOCAL, true);
+ backendTransactionManager.rollback();
+ verify(transactionStatus).setInTransaction(false);
+ verify(localTransactionManager).rollback();
}
@Test
public void assertRollbackForDistributedTransaction() throws SQLException {
ContextManager contextManager = mockContextManager();
- try (MockedStatic<ProxyContext> proxyContext = mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
- proxyContext.when(() -> ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
- newBackendTransactionManager(TransactionType.XA, true);
- backendTransactionManager.rollback();
- verify(transactionStatus).setInTransaction(false);
- verify(shardingSphereTransactionManager).rollback();
- }
+ when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ newBackendTransactionManager(TransactionType.XA, true);
+ backendTransactionManager.rollback();
+ verify(transactionStatus).setInTransaction(false);
+ verify(shardingSphereTransactionManager).rollback();
}
@Test
public void assertRollbackWithoutTransaction() throws SQLException {
ContextManager contextManager = mockContextManager();
- try (MockedStatic<ProxyContext> proxyContext = mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
- proxyContext.when(() -> ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
- newBackendTransactionManager(TransactionType.LOCAL, false);
- backendTransactionManager.rollback();
- verify(transactionStatus, times(0)).setInTransaction(false);
- verify(localTransactionManager, times(0)).rollback();
- verify(shardingSphereTransactionManager, times(0)).rollback();
- }
+ when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ newBackendTransactionManager(TransactionType.LOCAL, false);
+ backendTransactionManager.rollback();
+ verify(transactionStatus, times(0)).setInTransaction(false);
+ verify(localTransactionManager, times(0)).rollback();
+ verify(shardingSphereTransactionManager, times(0)).rollback();
}
private void newBackendTransactionManager(final TransactionType transactionType, final boolean inTransaction) {
diff --git a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/data/impl/UnicastDatabaseBackendHandlerTest.java b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/data/impl/UnicastDatabaseBackendHandlerTest.java
index a759ccd8a4c..9802b27eaaa 100644
--- a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/data/impl/UnicastDatabaseBackendHandlerTest.java
+++ b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/data/impl/UnicastDatabaseBackendHandlerTest.java
@@ -37,13 +37,15 @@ import org.apache.shardingsphere.proxy.backend.response.header.ResponseHeader;
import org.apache.shardingsphere.proxy.backend.response.header.update.UpdateResponseHeader;
import org.apache.shardingsphere.proxy.backend.session.ConnectionSession;
import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.apache.shardingsphere.test.mock.AutoMockExtension;
+import org.apache.shardingsphere.test.mock.StaticMockSettings;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
-import org.mockito.MockedStatic;
import org.mockito.internal.configuration.plugins.Plugins;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
import java.sql.SQLException;
import java.util.Collections;
@@ -58,10 +60,11 @@ import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.mockStatic;
import static org.mockito.Mockito.when;
-@RunWith(MockitoJUnitRunner.class)
+@ExtendWith(AutoMockExtension.class)
+@StaticMockSettings(ProxyContext.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
public final class UnicastDatabaseBackendHandlerTest {
private static final String EXECUTE_SQL = "SELECT 1 FROM user WHERE id = 1";
@@ -79,7 +82,7 @@ public final class UnicastDatabaseBackendHandlerTest {
@Mock
private DatabaseConnector databaseConnector;
- @Before
+ @BeforeEach
public void setUp() throws SQLException {
when(connectionSession.getDefaultDatabaseName()).thenReturn(String.format(DATABASE_PATTERN, 0));
when(connectionSession.getBackendConnection()).thenReturn(mock(BackendConnection.class));
@@ -102,38 +105,34 @@ public final class UnicastDatabaseBackendHandlerTest {
@Test
public void assertExecuteDatabaseBackendHandler() throws SQLException {
ContextManager contextManager = mockContextManager();
- try (MockedStatic<ProxyContext> proxyContext = mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
- proxyContext.when(() -> ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
- ShardingSphereDatabase database = getDatabases().get("db_0");
- proxyContext.when(() -> ProxyContext.getInstance().getDatabase("db_0")).thenReturn(database);
- ResponseHeader actual = unicastDatabaseBackendHandler.execute();
- assertThat(actual, instanceOf(UpdateResponseHeader.class));
- }
+ when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ ShardingSphereDatabase database = createDatabases().get("db_0");
+ when(ProxyContext.getInstance().getDatabase("db_0")).thenReturn(database);
+ ResponseHeader actual = unicastDatabaseBackendHandler.execute();
+ assertThat(actual, instanceOf(UpdateResponseHeader.class));
}
@Test
public void assertDatabaseUsingStream() throws SQLException {
ContextManager contextManager = mockContextManager();
- try (MockedStatic<ProxyContext> proxyContext = mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
- proxyContext.when(() -> ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
- ShardingSphereDatabase database = getDatabases().get("db_0");
- proxyContext.when(() -> ProxyContext.getInstance().getDatabase("db_0")).thenReturn(database);
- unicastDatabaseBackendHandler.execute();
- while (unicastDatabaseBackendHandler.next()) {
- assertThat(unicastDatabaseBackendHandler.getRowData().getData().size(), is(1));
- }
+ when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ ShardingSphereDatabase database = createDatabases().get("db_0");
+ when(ProxyContext.getInstance().getDatabase("db_0")).thenReturn(database);
+ unicastDatabaseBackendHandler.execute();
+ while (unicastDatabaseBackendHandler.next()) {
+ assertThat(unicastDatabaseBackendHandler.getRowData().getData().size(), is(1));
}
}
private ContextManager mockContextManager() {
ContextManager result = mock(ContextManager.class, RETURNS_DEEP_STUBS);
MetaDataContexts metaDataContexts = new MetaDataContexts(mock(MetaDataPersistService.class),
- new ShardingSphereMetaData(getDatabases(), mock(ShardingSphereRuleMetaData.class), new ConfigurationProperties(new Properties())));
+ new ShardingSphereMetaData(createDatabases(), mock(ShardingSphereRuleMetaData.class), new ConfigurationProperties(new Properties())));
when(result.getMetaDataContexts()).thenReturn(metaDataContexts);
return result;
}
- private Map<String, ShardingSphereDatabase> getDatabases() {
+ private Map<String, ShardingSphereDatabase> createDatabases() {
Map<String, ShardingSphereDatabase> result = new HashMap<>(10, 1);
for (int i = 0; i < 10; i++) {
ShardingSphereDatabase database = mock(ShardingSphereDatabase.class, RETURNS_DEEP_STUBS);
diff --git a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/database/DropDatabaseBackendHandlerTest.java b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/database/DropDatabaseBackendHandlerTest.java
index 93208609a1b..b202d5bb792 100644
--- a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/database/DropDatabaseBackendHandlerTest.java
+++ b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/database/DropDatabaseBackendHandlerTest.java
@@ -28,13 +28,14 @@ import org.apache.shardingsphere.proxy.backend.response.header.ResponseHeader;
import org.apache.shardingsphere.proxy.backend.response.header.update.UpdateResponseHeader;
import org.apache.shardingsphere.proxy.backend.session.ConnectionSession;
import org.apache.shardingsphere.sql.parser.sql.common.statement.ddl.DropDatabaseStatement;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.apache.shardingsphere.test.mock.AutoMockExtension;
+import org.apache.shardingsphere.test.mock.StaticMockSettings;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
-import org.mockito.MockedStatic;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
import java.util.Collections;
import java.util.HashMap;
@@ -42,18 +43,18 @@ import java.util.Map;
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.mockStatic;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-@RunWith(MockitoJUnitRunner.class)
+@ExtendWith(AutoMockExtension.class)
+@StaticMockSettings(ProxyContext.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
public final class DropDatabaseBackendHandlerTest {
- private MockedStatic<ProxyContext> proxyContext;
-
@Mock
private ConnectionSession connectionSession;
@@ -62,13 +63,12 @@ public final class DropDatabaseBackendHandlerTest {
private DropDatabaseBackendHandler handler;
- @Before
+ @BeforeEach
public void setUp() {
ContextManager contextManager = mockContextManager();
- proxyContext = mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS);
- proxyContext.when(() -> ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
- proxyContext.when(() -> ProxyContext.getInstance().databaseExists("test_db")).thenReturn(true);
- proxyContext.when(() -> ProxyContext.getInstance().databaseExists("other_db")).thenReturn(true);
+ when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ when(ProxyContext.getInstance().databaseExists("foo_db")).thenReturn(true);
+ when(ProxyContext.getInstance().databaseExists("bar_db")).thenReturn(true);
handler = new DropDatabaseBackendHandler(sqlStatement, connectionSession);
}
@@ -76,12 +76,12 @@ public final class DropDatabaseBackendHandlerTest {
Map<String, ShardingSphereDatabase> databases = new HashMap<>(2, 1);
ShardingSphereDatabase database = mock(ShardingSphereDatabase.class, RETURNS_DEEP_STUBS);
when(database.getRuleMetaData().getRules()).thenReturn(Collections.emptyList());
- databases.put("test_db", database);
- databases.put("other_db", database);
+ databases.put("foo_db", database);
+ databases.put("bar_db", database);
MetaDataContexts metaDataContexts = mock(MetaDataContexts.class, RETURNS_DEEP_STUBS);
when(metaDataContexts.getMetaData().getDatabases()).thenReturn(databases);
- when(metaDataContexts.getMetaData().getDatabase("test_db")).thenReturn(database);
- when(metaDataContexts.getMetaData().getDatabase("other_db")).thenReturn(database);
+ when(metaDataContexts.getMetaData().getDatabase("foo_db")).thenReturn(database);
+ when(metaDataContexts.getMetaData().getDatabase("bar_db")).thenReturn(database);
when(metaDataContexts.getMetaData().getDatabase("test_not_exist_db")).thenReturn(database);
when(metaDataContexts.getMetaData().getGlobalRuleMetaData()).thenReturn(new ShardingSphereRuleMetaData(Collections.singleton(mock(AuthorityRule.class))));
ContextManager result = mock(ContextManager.class, RETURNS_DEEP_STUBS);
@@ -89,15 +89,10 @@ public final class DropDatabaseBackendHandlerTest {
return result;
}
- @After
- public void tearDown() {
- proxyContext.close();
- }
-
- @Test(expected = DatabaseDropNotExistsException.class)
+ @Test
public void assertExecuteDropNotExistDatabase() {
when(sqlStatement.getDatabaseName()).thenReturn("test_not_exist_db");
- handler.execute();
+ assertThrows(DatabaseDropNotExistsException.class, () -> handler.execute());
}
@Test
@@ -109,7 +104,7 @@ public final class DropDatabaseBackendHandlerTest {
@Test
public void assertExecuteDropWithoutCurrentDatabase() {
- when(sqlStatement.getDatabaseName()).thenReturn("test_db");
+ when(sqlStatement.getDatabaseName()).thenReturn("foo_db");
ResponseHeader responseHeader = handler.execute();
verify(connectionSession, times(0)).setCurrentDatabase(null);
assertThat(responseHeader, instanceOf(UpdateResponseHeader.class));
@@ -117,8 +112,8 @@ public final class DropDatabaseBackendHandlerTest {
@Test
public void assertExecuteDropCurrentDatabase() {
- when(connectionSession.getDatabaseName()).thenReturn("test_db");
- when(sqlStatement.getDatabaseName()).thenReturn("test_db");
+ when(connectionSession.getDatabaseName()).thenReturn("foo_db");
+ when(sqlStatement.getDatabaseName()).thenReturn("foo_db");
ResponseHeader responseHeader = handler.execute();
verify(connectionSession).setCurrentDatabase(null);
assertThat(responseHeader, instanceOf(UpdateResponseHeader.class));
@@ -126,8 +121,8 @@ public final class DropDatabaseBackendHandlerTest {
@Test
public void assertExecuteDropOtherDatabase() {
- when(connectionSession.getDatabaseName()).thenReturn("test_db");
- when(sqlStatement.getDatabaseName()).thenReturn("other_db");
+ when(connectionSession.getDatabaseName()).thenReturn("foo_db");
+ when(sqlStatement.getDatabaseName()).thenReturn("bar_db");
ResponseHeader responseHeader = handler.execute();
verify(connectionSession, times(0)).setCurrentDatabase(null);
assertThat(responseHeader, instanceOf(UpdateResponseHeader.class));
diff --git a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/DistSQLBackendHandlerFactoryTest.java b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/DistSQLBackendHandlerFactoryTest.java
index 6971ca105a3..c2f902cd504 100644
--- a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/DistSQLBackendHandlerFactoryTest.java
+++ b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/DistSQLBackendHandlerFactoryTest.java
@@ -50,49 +50,44 @@ import org.apache.shardingsphere.shadow.distsql.parser.statement.ShowShadowAlgor
import org.apache.shardingsphere.shadow.distsql.parser.statement.ShowShadowRulesStatement;
import org.apache.shardingsphere.shadow.distsql.parser.statement.ShowShadowTableRulesStatement;
import org.apache.shardingsphere.sharding.distsql.parser.statement.CreateShardingTableRuleStatement;
+import org.apache.shardingsphere.test.mock.AutoMockExtension;
+import org.apache.shardingsphere.test.mock.StaticMockSettings;
import org.apache.shardingsphere.test.util.PropertiesBuilder;
import org.apache.shardingsphere.test.util.PropertiesBuilder.Property;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
-import org.mockito.MockedStatic;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
import java.sql.SQLException;
import java.util.Collections;
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.mockStatic;
import static org.mockito.Mockito.when;
-@RunWith(MockitoJUnitRunner.class)
+@ExtendWith(AutoMockExtension.class)
+@StaticMockSettings(ProxyContext.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
public final class DistSQLBackendHandlerFactoryTest {
- private MockedStatic<ProxyContext> proxyContext;
-
@Mock
private ConnectionSession connectionSession;
- @Before
+ @BeforeEach
public void setUp() {
ShardingSphereDatabase database = mockDatabase();
ContextManager contextManager = mockContextManager(database);
- proxyContext = mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS);
- proxyContext.when(() -> ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
- proxyContext.when(() -> ProxyContext.getInstance().databaseExists("db")).thenReturn(true);
- proxyContext.when(() -> ProxyContext.getInstance().getDatabase("db")).thenReturn(database);
- when(connectionSession.getDatabaseName()).thenReturn("db");
- }
-
- @After
- public void tearDown() {
- proxyContext.close();
+ when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ when(ProxyContext.getInstance().databaseExists("foo_db")).thenReturn(true);
+ when(ProxyContext.getInstance().getDatabase("foo_db")).thenReturn(database);
+ when(connectionSession.getDatabaseName()).thenReturn("foo_db");
}
private ShardingSphereDatabase mockDatabase() {
@@ -113,8 +108,7 @@ public final class DistSQLBackendHandlerFactoryTest {
private MetaDataContexts mockMetaDataContexts(final ShardingSphereDatabase database) {
MetaDataContexts result = mock(MetaDataContexts.class, RETURNS_DEEP_STUBS);
- when(result.getMetaData().containsDatabase("db")).thenReturn(true);
- when(result.getMetaData().getDatabase("db")).thenReturn(database);
+ when(result.getMetaData().getDatabase("foo_db")).thenReturn(database);
return result;
}
@@ -125,7 +119,7 @@ public final class DistSQLBackendHandlerFactoryTest {
@Test
public void assertExecuteShardingTableRuleContext() throws SQLException {
- when(ProxyContext.getInstance().getDatabase("db").getRuleMetaData()).thenReturn(new ShardingSphereRuleMetaData(Collections.emptyList()));
+ when(ProxyContext.getInstance().getDatabase("foo_db").getRuleMetaData()).thenReturn(new ShardingSphereRuleMetaData(Collections.emptyList()));
assertThat(RDLBackendHandlerFactory.newInstance(mock(CreateShardingTableRuleStatement.class), connectionSession).execute(), instanceOf(UpdateResponseHeader.class));
}
@@ -194,9 +188,9 @@ public final class DistSQLBackendHandlerFactoryTest {
assertThat(RDLBackendHandlerFactory.newInstance(mock(UnregisterStorageUnitStatement.class), connectionSession).execute(), instanceOf(UpdateResponseHeader.class));
}
- @Test(expected = MissingRequiredRuleException.class)
- public void assertExecuteDropReadwriteSplittingRuleContext() throws SQLException {
- assertThat(RDLBackendHandlerFactory.newInstance(mock(DropReadwriteSplittingRuleStatement.class), connectionSession).execute(), instanceOf(UpdateResponseHeader.class));
+ @Test
+ public void assertExecuteDropReadwriteSplittingRuleContext() {
+ assertThrows(MissingRequiredRuleException.class, () -> RDLBackendHandlerFactory.newInstance(mock(DropReadwriteSplittingRuleStatement.class), connectionSession).execute());
}
@Test
@@ -204,9 +198,9 @@ public final class DistSQLBackendHandlerFactoryTest {
assertThat(RDLBackendHandlerFactory.newInstance(mock(CreateReadwriteSplittingRuleStatement.class), connectionSession).execute(), instanceOf(UpdateResponseHeader.class));
}
- @Test(expected = MissingRequiredRuleException.class)
- public void assertExecuteAlterReadwriteSplittingRuleContext() throws SQLException {
- assertThat(RDLBackendHandlerFactory.newInstance(mock(AlterReadwriteSplittingRuleStatement.class), connectionSession).execute(), instanceOf(UpdateResponseHeader.class));
+ @Test
+ public void assertExecuteAlterReadwriteSplittingRuleContext() {
+ assertThrows(MissingRequiredRuleException.class, () -> RDLBackendHandlerFactory.newInstance(mock(AlterReadwriteSplittingRuleStatement.class), connectionSession).execute());
}
@Test
@@ -216,13 +210,13 @@ public final class DistSQLBackendHandlerFactoryTest {
private void mockShardingSphereRuleMetaData() {
ShardingSphereDatabase database = mock(ShardingSphereDatabase.class, RETURNS_DEEP_STUBS);
- when(database.getName()).thenReturn("db");
+ when(database.getName()).thenReturn("foo_db");
when(database.getResourceMetaData()).thenReturn(mock(ShardingSphereResourceMetaData.class));
ShardingSphereRuleMetaData ruleMetaData = mock(ShardingSphereRuleMetaData.class);
ShadowRuleConfiguration ruleConfig = mockShadowRuleConfiguration();
when(ruleMetaData.getConfigurations()).thenReturn(Collections.singleton(ruleConfig));
when(database.getRuleMetaData()).thenReturn(ruleMetaData);
- proxyContext.when(() -> ProxyContext.getInstance().getDatabase("db")).thenReturn(database);
+ when(ProxyContext.getInstance().getDatabase("foo_db")).thenReturn(database);
}
private ShadowRuleConfiguration mockShadowRuleConfiguration() {
diff --git a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/QueryableRALBackendHandlerTest.java b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/QueryableRALBackendHandlerTest.java
index 77898af7ccd..0cdb67f73ce 100644
--- a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/QueryableRALBackendHandlerTest.java
+++ b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/QueryableRALBackendHandlerTest.java
@@ -37,11 +37,10 @@ import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
import org.apache.shardingsphere.proxy.backend.session.ConnectionSession;
import org.apache.shardingsphere.sql.parser.sql.common.segment.generic.DatabaseSegment;
import org.apache.shardingsphere.sql.parser.sql.common.value.identifier.IdentifierValue;
-import org.junit.jupiter.api.AfterEach;
+import org.apache.shardingsphere.test.mock.AutoMockExtension;
+import org.apache.shardingsphere.test.mock.StaticMockSettings;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.MockedStatic;
-import org.mockito.junit.jupiter.MockitoExtension;
import java.util.Collection;
import java.util.Collections;
@@ -51,19 +50,12 @@ import java.util.Map;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.mockStatic;
import static org.mockito.Mockito.when;
-@ExtendWith(MockitoExtension.class)
+@ExtendWith(AutoMockExtension.class)
+@StaticMockSettings(ProxyContext.class)
public final class QueryableRALBackendHandlerTest {
- private final MockedStatic<ProxyContext> proxyContext = mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS);
-
- @AfterEach
- public void tearDown() {
- proxyContext.close();
- }
-
@Test
public void assertExecuteWithNoDatabase() {
ConnectionSession connectionSession = mock(ConnectionSession.class);
@@ -78,7 +70,7 @@ public final class QueryableRALBackendHandlerTest {
ConnectionSession connectionSession = mock(ConnectionSession.class);
when(connectionSession.getDatabaseName()).thenReturn("unknown");
ContextManager contextManager = new ContextManager(metaDataContexts, mock(InstanceContext.class));
- proxyContext.when(() -> ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
assertThrows(UnknownDatabaseException.class, () -> new QueryableRALBackendHandler<>(mock(ExportDatabaseConfigurationStatement.class), connectionSession).execute());
}
@@ -94,9 +86,9 @@ public final class QueryableRALBackendHandlerTest {
when(database.getSchema("db_name")).thenReturn(new ShardingSphereSchema(createTableMap(), Collections.emptyMap()));
when(contextManager.getMetaDataContexts().getMetaData().getDatabases()).thenReturn(Collections.singletonMap("db_name", database));
when(contextManager.getMetaDataContexts().getMetaData().getDatabase("db_name")).thenReturn(database);
- proxyContext.when(() -> ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
- proxyContext.when(() -> ProxyContext.getInstance().databaseExists("db_name")).thenReturn(true);
- proxyContext.when(() -> ProxyContext.getInstance().getDatabase("db_name")).thenReturn(database);
+ when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ when(ProxyContext.getInstance().databaseExists("db_name")).thenReturn(true);
+ when(ProxyContext.getInstance().getDatabase("db_name")).thenReturn(database);
ConnectionSession connectionSession = mock(ConnectionSession.class, RETURNS_DEEP_STUBS);
when(connectionSession.getDatabaseName()).thenReturn("db_name");
new QueryableRALBackendHandler<>(createSqlStatement(), connectionSession).execute();
diff --git a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/updatable/ImportMetaDataUpdaterTest.java b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/updatable/ImportMetaDataUpdaterTest.java
index 378a110b8cc..7f3deaf034c 100644
--- a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/updatable/ImportMetaDataUpdaterTest.java
+++ b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/updatable/ImportMetaDataUpdaterTest.java
@@ -29,17 +29,17 @@ import org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSp
import org.apache.shardingsphere.mode.manager.ContextManager;
import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
import org.apache.shardingsphere.test.fixture.jdbc.MockedDataSource;
+import org.apache.shardingsphere.test.mock.AutoMockExtension;
+import org.apache.shardingsphere.test.mock.StaticMockSettings;
import org.apache.shardingsphere.test.util.PropertiesBuilder;
import org.apache.shardingsphere.test.util.PropertiesBuilder.Property;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.MockedStatic;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
import javax.sql.DataSource;
-import java.sql.SQLException;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
@@ -47,12 +47,14 @@ import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Objects;
+import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.mockStatic;
import static org.mockito.Mockito.when;
-@RunWith(MockitoJUnitRunner.class)
+@ExtendWith(AutoMockExtension.class)
+@StaticMockSettings(ProxyContext.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
public final class ImportMetaDataUpdaterTest {
private static final String METADATA_VALUE = "{\"storageNodes\":[{\"ip\":\"127.0.0.1\",\"port\":\"3306\",\"username\":\"root\",\"password\":\"\",\"database\":\"demo_ds_0\"}],"
@@ -61,47 +63,40 @@ public final class ImportMetaDataUpdaterTest {
private final String empty = "empty_metadata";
- private final MockedStatic<ProxyContext> proxyContext = mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS);
-
private ImportMetaDataUpdater importMetaDataUpdater;
private final Map<String, String> featureMap = new HashMap<>(1, 1);
- @Before
+ @BeforeEach
public void setup() {
featureMap.put(empty, "/conf/import/empty-metadata.json");
}
- @After
- public void tearDown() {
- proxyContext.close();
- }
-
- @Test(expected = IllegalStateException.class)
- public void assertCheckImportEmptyMetaData() throws SQLException {
+ @Test
+ public void assertCheckImportEmptyMetaData() {
init(null);
- importMetaDataUpdater.executeUpdate(empty, new ImportMetaDataStatement(null, Objects.requireNonNull(ImportMetaDataUpdaterTest.class.getResource(featureMap.get(empty))).getPath()));
+ assertThrows(IllegalStateException.class, () -> importMetaDataUpdater.executeUpdate(
+ empty, new ImportMetaDataStatement(null, Objects.requireNonNull(ImportMetaDataUpdaterTest.class.getResource(featureMap.get(empty))).getPath())));
}
- @Test(expected = NullPointerException.class)
- public void assertImportMetaDataFromJsonValue() throws SQLException {
+ @Test
+ public void assertImportMetaDataFromJsonValue() {
init(empty);
- importMetaDataUpdater.executeUpdate(empty, new ImportMetaDataStatement(METADATA_VALUE, null));
+ assertThrows(NullPointerException.class, () -> importMetaDataUpdater.executeUpdate(empty, new ImportMetaDataStatement(METADATA_VALUE, null)));
}
- @Test(expected = IllegalStateException.class)
- public void assertImportExistedMetaDataFromFile() throws SQLException {
+ @Test
+ public void assertImportExistedMetaDataFromFile() {
init(empty);
- importMetaDataUpdater.executeUpdate(empty,
- new ImportMetaDataStatement(null, Objects.requireNonNull(ImportMetaDataUpdaterTest.class.getResource(featureMap.get(empty))).getPath()));
+ assertThrows(IllegalStateException.class, () -> importMetaDataUpdater.executeUpdate(
+ empty, new ImportMetaDataStatement(null, Objects.requireNonNull(ImportMetaDataUpdaterTest.class.getResource(featureMap.get(empty))).getPath())));
}
- @SuppressWarnings("ResultOfMethodCallIgnored")
private void init(final String feature) {
importMetaDataUpdater = new ImportMetaDataUpdater();
ContextManager contextManager = mockContextManager(feature);
- proxyContext.when(() -> ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
- proxyContext.when(() -> ProxyContext.getInstance().databaseExists(feature)).thenReturn(true);
+ when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ when(ProxyContext.getInstance().databaseExists(feature)).thenReturn(true);
}
private ContextManager mockContextManager(final String feature) {
diff --git a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/updatable/RefreshTableMetaDataUpdaterTest.java b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/updatable/RefreshTableMetaDataUpdaterTest.java
index ea8966f31e7..d38f2b8e715 100644
--- a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/updatable/RefreshTableMetaDataUpdaterTest.java
+++ b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/updatable/RefreshTableMetaDataUpdaterTest.java
@@ -29,74 +29,68 @@ import org.apache.shardingsphere.proxy.backend.response.header.ResponseHeader;
import org.apache.shardingsphere.proxy.backend.response.header.update.UpdateResponseHeader;
import org.apache.shardingsphere.proxy.backend.session.ConnectionSession;
import org.apache.shardingsphere.test.fixture.jdbc.MockedDataSource;
-import org.junit.Test;
-import org.mockito.MockedStatic;
+import org.apache.shardingsphere.test.mock.AutoMockExtension;
+import org.apache.shardingsphere.test.mock.StaticMockSettings;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
import java.sql.SQLException;
import java.util.Collections;
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.mockStatic;
import static org.mockito.Mockito.when;
+@ExtendWith(AutoMockExtension.class)
+@StaticMockSettings(ProxyContext.class)
public final class RefreshTableMetaDataUpdaterTest {
- @Test(expected = NoDatabaseSelectedException.class)
- public void assertNoDatabaseSelected() throws SQLException {
- UpdatableRALBackendHandler backendHandler = new UpdatableRALBackendHandler(new RefreshTableMetaDataStatement(), mock(ConnectionSession.class));
- try (MockedStatic<ProxyContext> proxyContext = mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
- proxyContext.when(() -> ProxyContext.getInstance().getContextManager()).thenReturn(mock(ContextManager.class, RETURNS_DEEP_STUBS));
- backendHandler.execute();
- }
+ @Test
+ public void assertNoDatabaseSelected() {
+ when(ProxyContext.getInstance().getContextManager()).thenReturn(mock(ContextManager.class, RETURNS_DEEP_STUBS));
+ UpdatableRALBackendHandler<?> backendHandler = new UpdatableRALBackendHandler<>(new RefreshTableMetaDataStatement(), mock(ConnectionSession.class));
+ assertThrows(NoDatabaseSelectedException.class, backendHandler::execute);
}
- @Test(expected = UnknownDatabaseException.class)
- public void assertUnknownDatabaseException() throws SQLException {
- UpdatableRALBackendHandler backendHandler = new UpdatableRALBackendHandler(new RefreshTableMetaDataStatement(), mockConnectionSession("not_existed_db"));
- try (MockedStatic<ProxyContext> proxyContext = mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
- proxyContext.when(() -> ProxyContext.getInstance().getContextManager()).thenReturn(mock(ContextManager.class, RETURNS_DEEP_STUBS));
- backendHandler.execute();
- }
+ @Test
+ public void assertUnknownDatabaseException() {
+ when(ProxyContext.getInstance().getContextManager()).thenReturn(mock(ContextManager.class, RETURNS_DEEP_STUBS));
+ UpdatableRALBackendHandler<?> backendHandler = new UpdatableRALBackendHandler<>(new RefreshTableMetaDataStatement(), mockConnectionSession("not_existed_db"));
+ assertThrows(UnknownDatabaseException.class, backendHandler::execute);
}
- @Test(expected = EmptyStorageUnitException.class)
- public void assertEmptyResource() throws SQLException {
- UpdatableRALBackendHandler backendHandler = new UpdatableRALBackendHandler(new RefreshTableMetaDataStatement(), mockConnectionSession("sharding_db"));
+ @Test
+ public void assertEmptyResource() {
ContextManager contextManager = mock(ContextManager.class, RETURNS_DEEP_STUBS);
- when(contextManager.getDataSourceMap("sharding_db")).thenReturn(Collections.emptyMap());
- try (MockedStatic<ProxyContext> proxyContext = mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
- proxyContext.when(() -> ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
- proxyContext.when(() -> ProxyContext.getInstance().databaseExists("sharding_db")).thenReturn(true);
- backendHandler.execute();
- }
+ when(contextManager.getDataSourceMap("foo_db")).thenReturn(Collections.emptyMap());
+ when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ when(ProxyContext.getInstance().databaseExists("foo_db")).thenReturn(true);
+ UpdatableRALBackendHandler<?> backendHandler = new UpdatableRALBackendHandler<>(new RefreshTableMetaDataStatement(), mockConnectionSession("foo_db"));
+ assertThrows(EmptyStorageUnitException.class, backendHandler::execute);
}
- @Test(expected = MissingRequiredStorageUnitsException.class)
- public void assertMissingRequiredResources() throws SQLException {
- UpdatableRALBackendHandler backendHandler = new UpdatableRALBackendHandler(new RefreshTableMetaDataStatement("t_order", "ds_1", null), mockConnectionSession("sharding_db"));
+ @Test
+ public void assertMissingRequiredResources() {
ContextManager contextManager = mock(ContextManager.class, RETURNS_DEEP_STUBS);
- when(contextManager.getDataSourceMap("sharding_db")).thenReturn(Collections.singletonMap("ds_0", new MockedDataSource()));
- try (MockedStatic<ProxyContext> proxyContext = mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
- proxyContext.when(() -> ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
- proxyContext.when(() -> ProxyContext.getInstance().databaseExists("sharding_db")).thenReturn(true);
- backendHandler.execute();
- }
+ when(contextManager.getDataSourceMap("foo_db")).thenReturn(Collections.singletonMap("ds_0", new MockedDataSource()));
+ when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ when(ProxyContext.getInstance().databaseExists("foo_db")).thenReturn(true);
+ UpdatableRALBackendHandler<?> backendHandler = new UpdatableRALBackendHandler<>(new RefreshTableMetaDataStatement("t_order", "ds_1", null), mockConnectionSession("foo_db"));
+ assertThrows(MissingRequiredStorageUnitsException.class, backendHandler::execute);
}
@Test
public void assertUpdate() throws SQLException {
- UpdatableRALBackendHandler backendHandler = new UpdatableRALBackendHandler(new RefreshTableMetaDataStatement(), mockConnectionSession("sharding_db"));
ContextManager contextManager = mock(ContextManager.class, RETURNS_DEEP_STUBS);
- when(contextManager.getDataSourceMap("sharding_db")).thenReturn(Collections.singletonMap("ds_0", new MockedDataSource()));
- try (MockedStatic<ProxyContext> proxyContext = mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
- proxyContext.when(() -> ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
- proxyContext.when(() -> ProxyContext.getInstance().databaseExists("sharding_db")).thenReturn(true);
- ResponseHeader actual = backendHandler.execute();
- assertThat(actual, instanceOf(UpdateResponseHeader.class));
- }
+ when(contextManager.getDataSourceMap("foo_db")).thenReturn(Collections.singletonMap("ds_0", new MockedDataSource()));
+ when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ when(ProxyContext.getInstance().databaseExists("foo_db")).thenReturn(true);
+ UpdatableRALBackendHandler<?> backendHandler = new UpdatableRALBackendHandler<>(new RefreshTableMetaDataStatement(), mockConnectionSession("foo_db"));
+ ResponseHeader actual = backendHandler.execute();
+ assertThat(actual, instanceOf(UpdateResponseHeader.class));
}
private static ConnectionSession mockConnectionSession(final String databaseName) {
diff --git a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/transaction/TransactionBackendHandlerTest.java b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/transaction/TransactionBackendHandlerTest.java
index e9e28f29b7a..96eda4550e3 100644
--- a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/transaction/TransactionBackendHandlerTest.java
+++ b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/transaction/TransactionBackendHandlerTest.java
@@ -24,10 +24,12 @@ import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
import org.apache.shardingsphere.proxy.backend.response.header.update.UpdateResponseHeader;
import org.apache.shardingsphere.proxy.backend.session.ConnectionSession;
import org.apache.shardingsphere.sql.parser.sql.common.statement.tcl.TCLStatement;
+import org.apache.shardingsphere.test.mock.AutoMockExtension;
+import org.apache.shardingsphere.test.mock.StaticMockSettings;
import org.apache.shardingsphere.transaction.core.TransactionOperationType;
import org.apache.shardingsphere.transaction.rule.TransactionRule;
-import org.junit.Test;
-import org.mockito.MockedStatic;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
import java.sql.SQLException;
import java.util.Collections;
@@ -36,9 +38,10 @@ import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.mockStatic;
import static org.mockito.Mockito.when;
+@ExtendWith(AutoMockExtension.class)
+@StaticMockSettings(ProxyContext.class)
public final class TransactionBackendHandlerTest {
private final ConnectionSession connectionSession = mock(ConnectionSession.class, RETURNS_DEEP_STUBS);
@@ -49,10 +52,8 @@ public final class TransactionBackendHandlerTest {
when(connectionSession.getBackendConnection()).thenReturn(backendConnection);
when(backendConnection.getConnectionSession()).thenReturn(connectionSession);
ContextManager contextManager = mockContextManager();
- try (MockedStatic<ProxyContext> proxyContext = mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
- proxyContext.when(() -> ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
- assertThat(new TransactionBackendHandler(mock(TCLStatement.class), TransactionOperationType.BEGIN, connectionSession).execute(), instanceOf(UpdateResponseHeader.class));
- }
+ when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ assertThat(new TransactionBackendHandler(mock(TCLStatement.class), TransactionOperationType.BEGIN, connectionSession).execute(), instanceOf(UpdateResponseHeader.class));
}
private static ContextManager mockContextManager() {
diff --git a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/session/ConnectionSessionTest.java b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/session/ConnectionSessionTest.java
index f6f3af92114..5acd128f1e8 100644
--- a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/session/ConnectionSessionTest.java
+++ b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/session/ConnectionSessionTest.java
@@ -24,30 +24,34 @@ import org.apache.shardingsphere.mode.manager.ContextManager;
import org.apache.shardingsphere.proxy.backend.connector.BackendConnection;
import org.apache.shardingsphere.proxy.backend.connector.jdbc.transaction.BackendTransactionManager;
import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
+import org.apache.shardingsphere.test.mock.AutoMockExtension;
+import org.apache.shardingsphere.test.mock.StaticMockSettings;
import org.apache.shardingsphere.transaction.api.TransactionType;
import org.apache.shardingsphere.transaction.exception.SwitchTypeInTransactionException;
import org.apache.shardingsphere.transaction.rule.TransactionRule;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
-import org.mockito.MockedStatic;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
import java.util.Collections;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+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.mockStatic;
import static org.mockito.Mockito.when;
-@RunWith(MockitoJUnitRunner.class)
+@ExtendWith(AutoMockExtension.class)
+@StaticMockSettings(ProxyContext.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
public final class ConnectionSessionTest {
@Mock
@@ -55,7 +59,7 @@ public final class ConnectionSessionTest {
private ConnectionSession connectionSession;
- @Before
+ @BeforeEach
public void setup() {
connectionSession = new ConnectionSession(mock(MySQLDatabaseType.class), TransactionType.LOCAL, null);
when(backendConnection.getConnectionSession()).thenReturn(connectionSession);
@@ -67,27 +71,23 @@ public final class ConnectionSessionTest {
assertThat(connectionSession.getDatabaseName(), is("currentDatabase"));
}
- @Test(expected = SwitchTypeInTransactionException.class)
+ @Test
public void assertFailedSwitchTransactionTypeWhileBegin() {
connectionSession.setCurrentDatabase("db");
ContextManager contextManager = mockContextManager();
- try (MockedStatic<ProxyContext> proxyContext = mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
- proxyContext.when(() -> ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
- new BackendTransactionManager(backendConnection).begin();
- connectionSession.getTransactionStatus().setTransactionType(TransactionType.XA);
- }
+ when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ new BackendTransactionManager(backendConnection).begin();
+ assertThrows(SwitchTypeInTransactionException.class, () -> connectionSession.getTransactionStatus().setTransactionType(TransactionType.XA));
}
@Test
public void assertSwitchSchemaWhileBegin() {
connectionSession.setCurrentDatabase("db");
ContextManager contextManager = mockContextManager();
- try (MockedStatic<ProxyContext> proxyContext = mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
- proxyContext.when(() -> ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
- new BackendTransactionManager(backendConnection).begin();
- connectionSession.setCurrentDatabase("newDB");
- assertThat(connectionSession.getDefaultDatabaseName(), is("newDB"));
- }
+ when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ new BackendTransactionManager(backendConnection).begin();
+ connectionSession.setCurrentDatabase("newDB");
+ assertThat(connectionSession.getDefaultDatabaseName(), is("newDB"));
}
private ContextManager mockContextManager() {