This is an automated email from the ASF dual-hosted git repository.
zhangliang 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 ee3ccb285b5 Refactor DistSQLProxyBackendHandlerFactory (#36831)
ee3ccb285b5 is described below
commit ee3ccb285b5719c2fcd6fc3e479a74133cdde930
Author: Liang Zhang <[email protected]>
AuthorDate: Fri Oct 10 12:45:40 2025 +0800
Refactor DistSQLProxyBackendHandlerFactory (#36831)
* Refactor DistSQLProxyBackendHandlerFactory
* Refactor DistSQLProxyBackendHandlerFactory
* Refactor DistSQLProxyBackendHandlerFactory
* Refactor DistSQLProxyBackendHandlerFactory
---
.../DatabaseOperateProxyBackendHandlerFactory.java | 7 +-
.../type/CreateDatabaseProxyBackendHandler.java | 6 +-
.../type/DropDatabaseProxyBackendHandler.java | 6 +-
.../distsql/DistSQLProxyBackendHandlerFactory.java | 11 ++-
.../distsql/DistSQLQueryProxyBackendHandler.java | 6 +-
.../distsql/DistSQLUpdateProxyBackendHandler.java | 6 +-
.../CreateDatabaseProxyBackendHandlerTest.java | 13 ++--
.../type/DropDatabaseProxyBackendHandlerTest.java | 9 +--
.../DistSQLProxyBackendHandlerFactoryTest.java | 88 ++++++++++++----------
.../DistSQLQueryProxyBackendHandlerTest.java | 14 ++--
.../DistSQLUpdateProxyBackendHandlerTest.java | 26 +++----
.../distsql/rul/ParseDistSQLExecutorTest.java | 14 ++--
12 files changed, 103 insertions(+), 103 deletions(-)
diff --git
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/database/DatabaseOperateProxyBackendHandlerFactory.java
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/database/DatabaseOperateProxyBackendHandlerFactory.java
index f7c387390e7..09ce0b564c5 100644
---
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/database/DatabaseOperateProxyBackendHandlerFactory.java
+++
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/database/DatabaseOperateProxyBackendHandlerFactory.java
@@ -21,6 +21,8 @@ import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import
org.apache.shardingsphere.infra.exception.generic.UnsupportedSQLOperationException;
import org.apache.shardingsphere.infra.metadata.ShardingSphereMetaData;
+import
org.apache.shardingsphere.mode.persist.service.MetaDataManagerPersistService;
+import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
import org.apache.shardingsphere.proxy.backend.handler.ProxyBackendHandler;
import
org.apache.shardingsphere.proxy.backend.handler.database.type.CreateDatabaseProxyBackendHandler;
import
org.apache.shardingsphere.proxy.backend.handler.database.type.DropDatabaseProxyBackendHandler;
@@ -48,11 +50,12 @@ public final class
DatabaseOperateProxyBackendHandlerFactory {
}
private static ProxyBackendHandler createProxyBackendHandler(final
SQLStatement sqlStatement, final ShardingSphereMetaData metaData, final
ConnectionSession connectionSession) {
+ MetaDataManagerPersistService metaDataManagerPersistService =
ProxyContext.getInstance().getContextManager().getPersistServiceFacade().getModeFacade().getMetaDataManagerService();
if (sqlStatement instanceof CreateDatabaseStatement) {
- return new
CreateDatabaseProxyBackendHandler((CreateDatabaseStatement) sqlStatement,
metaData);
+ return new
CreateDatabaseProxyBackendHandler((CreateDatabaseStatement) sqlStatement,
metaData, metaDataManagerPersistService);
}
if (sqlStatement instanceof DropDatabaseStatement) {
- return new DropDatabaseProxyBackendHandler((DropDatabaseStatement)
sqlStatement, metaData, connectionSession);
+ return new DropDatabaseProxyBackendHandler((DropDatabaseStatement)
sqlStatement, metaData, metaDataManagerPersistService, connectionSession);
}
throw new
UnsupportedSQLOperationException(sqlStatement.getClass().getName());
}
diff --git
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/database/type/CreateDatabaseProxyBackendHandler.java
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/database/type/CreateDatabaseProxyBackendHandler.java
index 95242f322b5..b8238b26d63 100644
---
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/database/type/CreateDatabaseProxyBackendHandler.java
+++
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/database/type/CreateDatabaseProxyBackendHandler.java
@@ -21,7 +21,7 @@ import lombok.RequiredArgsConstructor;
import
org.apache.shardingsphere.database.exception.core.exception.syntax.database.DatabaseCreateExistsException;
import org.apache.shardingsphere.infra.exception.ShardingSpherePreconditions;
import org.apache.shardingsphere.infra.metadata.ShardingSphereMetaData;
-import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
+import
org.apache.shardingsphere.mode.persist.service.MetaDataManagerPersistService;
import org.apache.shardingsphere.proxy.backend.handler.ProxyBackendHandler;
import org.apache.shardingsphere.proxy.backend.response.header.ResponseHeader;
import
org.apache.shardingsphere.proxy.backend.response.header.update.UpdateResponseHeader;
@@ -39,11 +39,13 @@ public final class CreateDatabaseProxyBackendHandler
implements ProxyBackendHand
private final ShardingSphereMetaData metaData;
+ private final MetaDataManagerPersistService metaDataManagerPersistService;
+
@Override
public ResponseHeader execute() throws SQLException {
ShardingSpherePreconditions.checkState(sqlStatement.isIfNotExists() ||
!metaData.containsDatabase(sqlStatement.getDatabaseName()),
() -> new
DatabaseCreateExistsException(sqlStatement.getDatabaseName()));
-
ProxyContext.getInstance().getContextManager().getPersistServiceFacade().getModeFacade().getMetaDataManagerService().createDatabase(sqlStatement.getDatabaseName());
+
metaDataManagerPersistService.createDatabase(sqlStatement.getDatabaseName());
return new UpdateResponseHeader(sqlStatement);
}
}
diff --git
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/database/type/DropDatabaseProxyBackendHandler.java
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/database/type/DropDatabaseProxyBackendHandler.java
index 2968c3aff75..f8e22583f32 100644
---
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/database/type/DropDatabaseProxyBackendHandler.java
+++
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/database/type/DropDatabaseProxyBackendHandler.java
@@ -29,7 +29,7 @@ import
org.apache.shardingsphere.infra.exception.ShardingSpherePreconditions;
import org.apache.shardingsphere.infra.metadata.ShardingSphereMetaData;
import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import org.apache.shardingsphere.infra.metadata.user.Grantee;
-import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
+import
org.apache.shardingsphere.mode.persist.service.MetaDataManagerPersistService;
import org.apache.shardingsphere.proxy.backend.handler.ProxyBackendHandler;
import org.apache.shardingsphere.proxy.backend.response.header.ResponseHeader;
import
org.apache.shardingsphere.proxy.backend.response.header.update.UpdateResponseHeader;
@@ -48,6 +48,8 @@ public final class DropDatabaseProxyBackendHandler implements
ProxyBackendHandle
private final ShardingSphereMetaData metaData;
+ private final MetaDataManagerPersistService metaDataManagerPersistService;
+
private final ConnectionSession connectionSession;
@Override
@@ -59,7 +61,7 @@ public final class DropDatabaseProxyBackendHandler implements
ProxyBackendHandle
}
if (metaData.containsDatabase(sqlStatement.getDatabaseName())) {
ShardingSphereDatabase database =
metaData.getDatabase(sqlStatement.getDatabaseName());
-
ProxyContext.getInstance().getContextManager().getPersistServiceFacade().getModeFacade().getMetaDataManagerService().dropDatabase(database);
+ metaDataManagerPersistService.dropDatabase(database);
}
return new UpdateResponseHeader(sqlStatement);
}
diff --git
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/DistSQLProxyBackendHandlerFactory.java
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/DistSQLProxyBackendHandlerFactory.java
index 13ad3eb8962..9d6ac67bb08 100644
---
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/DistSQLProxyBackendHandlerFactory.java
+++
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/DistSQLProxyBackendHandlerFactory.java
@@ -27,6 +27,8 @@ import
org.apache.shardingsphere.distsql.statement.type.rql.RQLStatement;
import org.apache.shardingsphere.distsql.statement.type.rul.RULStatement;
import
org.apache.shardingsphere.infra.exception.generic.UnsupportedSQLOperationException;
import org.apache.shardingsphere.infra.session.query.QueryContext;
+import org.apache.shardingsphere.mode.manager.ContextManager;
+import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
import org.apache.shardingsphere.proxy.backend.handler.ProxyBackendHandler;
import org.apache.shardingsphere.proxy.backend.session.ConnectionSession;
@@ -46,16 +48,17 @@ public final class DistSQLProxyBackendHandlerFactory {
* @throws UnsupportedSQLOperationException unsupported SQL operation
exception
*/
public static ProxyBackendHandler newInstance(final DistSQLStatement
sqlStatement, final QueryContext queryContext, final ConnectionSession
connectionSession) {
+ ContextManager contextManager =
ProxyContext.getInstance().getContextManager();
if (sqlStatement instanceof RQLStatement || sqlStatement instanceof
RULStatement) {
- return new DistSQLQueryProxyBackendHandler(sqlStatement,
queryContext, connectionSession);
+ return new DistSQLQueryProxyBackendHandler(sqlStatement,
queryContext, connectionSession, contextManager);
}
if (sqlStatement instanceof RDLStatement) {
- return new DistSQLUpdateProxyBackendHandler(sqlStatement,
connectionSession);
+ return new DistSQLUpdateProxyBackendHandler(sqlStatement,
connectionSession, contextManager);
}
if (sqlStatement instanceof RALStatement) {
return sqlStatement instanceof QueryableRALStatement
- ? new DistSQLQueryProxyBackendHandler(sqlStatement,
queryContext, connectionSession)
- : new DistSQLUpdateProxyBackendHandler(sqlStatement,
connectionSession);
+ ? new DistSQLQueryProxyBackendHandler(sqlStatement,
queryContext, connectionSession, contextManager)
+ : new DistSQLUpdateProxyBackendHandler(sqlStatement,
connectionSession, contextManager);
}
throw new
UnsupportedSQLOperationException(sqlStatement.getClass().getName());
}
diff --git
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/DistSQLQueryProxyBackendHandler.java
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/DistSQLQueryProxyBackendHandler.java
index 79c05cf672d..463f88371de 100644
---
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/DistSQLQueryProxyBackendHandler.java
+++
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/DistSQLQueryProxyBackendHandler.java
@@ -23,7 +23,7 @@ import
org.apache.shardingsphere.distsql.statement.DistSQLStatement;
import org.apache.shardingsphere.infra.merge.result.MergedResult;
import
org.apache.shardingsphere.infra.merge.result.impl.local.LocalDataMergedResult;
import org.apache.shardingsphere.infra.session.query.QueryContext;
-import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
+import org.apache.shardingsphere.mode.manager.ContextManager;
import org.apache.shardingsphere.proxy.backend.response.data.QueryResponseCell;
import org.apache.shardingsphere.proxy.backend.response.data.QueryResponseRow;
import org.apache.shardingsphere.proxy.backend.response.header.ResponseHeader;
@@ -49,11 +49,11 @@ public final class DistSQLQueryProxyBackendHandler
implements DistSQLProxyBacken
private MergedResult mergedResult;
- public DistSQLQueryProxyBackendHandler(final DistSQLStatement
sqlStatement, final QueryContext queryContext, final ConnectionSession
connectionSession) {
+ public DistSQLQueryProxyBackendHandler(final DistSQLStatement
sqlStatement, final QueryContext queryContext, final ConnectionSession
connectionSession, final ContextManager contextManager) {
DistSQLConnectionContext distsqlConnectionContext = new
DistSQLConnectionContext(queryContext,
connectionSession.getDatabaseConnectionManager().getConnectionSize(),
connectionSession.getProtocolType(),
connectionSession.getDatabaseConnectionManager(),
connectionSession.getStatementManager());
- engine = new DistSQLQueryExecuteEngine(sqlStatement,
connectionSession.getUsedDatabaseName(),
ProxyContext.getInstance().getContextManager(), distsqlConnectionContext);
+ engine = new DistSQLQueryExecuteEngine(sqlStatement,
connectionSession.getUsedDatabaseName(), contextManager,
distsqlConnectionContext);
}
@Override
diff --git
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/DistSQLUpdateProxyBackendHandler.java
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/DistSQLUpdateProxyBackendHandler.java
index be4830395d0..2e5f326dc56 100644
---
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/DistSQLUpdateProxyBackendHandler.java
+++
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/DistSQLUpdateProxyBackendHandler.java
@@ -19,7 +19,7 @@ package
org.apache.shardingsphere.proxy.backend.handler.distsql;
import
org.apache.shardingsphere.distsql.handler.engine.update.DistSQLUpdateExecuteEngine;
import org.apache.shardingsphere.distsql.statement.DistSQLStatement;
-import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
+import org.apache.shardingsphere.mode.manager.ContextManager;
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;
@@ -35,9 +35,9 @@ public final class DistSQLUpdateProxyBackendHandler
implements DistSQLProxyBacke
private final DistSQLUpdateExecuteEngine engine;
- public DistSQLUpdateProxyBackendHandler(final DistSQLStatement
sqlStatement, final ConnectionSession connectionSession) {
+ public DistSQLUpdateProxyBackendHandler(final DistSQLStatement
sqlStatement, final ConnectionSession connectionSession, final ContextManager
contextManager) {
this.sqlStatement = sqlStatement;
- engine = new DistSQLUpdateExecuteEngine(sqlStatement,
connectionSession.getUsedDatabaseName(),
ProxyContext.getInstance().getContextManager());
+ engine = new DistSQLUpdateExecuteEngine(sqlStatement,
connectionSession.getUsedDatabaseName(), contextManager);
}
@Override
diff --git
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/database/type/CreateDatabaseProxyBackendHandlerTest.java
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/database/type/CreateDatabaseProxyBackendHandlerTest.java
index 060a36f71b7..b4c5509abcd 100644
---
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/database/type/CreateDatabaseProxyBackendHandlerTest.java
+++
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/database/type/CreateDatabaseProxyBackendHandlerTest.java
@@ -19,14 +19,12 @@ package
org.apache.shardingsphere.proxy.backend.handler.database.type;
import
org.apache.shardingsphere.database.exception.core.exception.syntax.database.DatabaseCreateExistsException;
import org.apache.shardingsphere.infra.metadata.ShardingSphereMetaData;
-import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
import
org.apache.shardingsphere.proxy.backend.response.header.update.UpdateResponseHeader;
import
org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.database.CreateDatabaseStatement;
-import org.apache.shardingsphere.test.infra.framework.mock.AutoMockExtension;
-import org.apache.shardingsphere.test.infra.framework.mock.StaticMockSettings;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
import java.sql.SQLException;
@@ -36,8 +34,7 @@ import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-@ExtendWith(AutoMockExtension.class)
-@StaticMockSettings(ProxyContext.class)
+@ExtendWith(MockitoExtension.class)
class CreateDatabaseProxyBackendHandlerTest {
@Mock
@@ -46,7 +43,7 @@ class CreateDatabaseProxyBackendHandlerTest {
@Test
void assertExecuteCreateNewDatabase() throws SQLException {
when(statement.getDatabaseName()).thenReturn("bar_db");
- assertThat(new CreateDatabaseProxyBackendHandler(statement,
mock()).execute(), isA(UpdateResponseHeader.class));
+ assertThat(new CreateDatabaseProxyBackendHandler(statement, mock(),
mock()).execute(), isA(UpdateResponseHeader.class));
}
@Test
@@ -54,13 +51,13 @@ class CreateDatabaseProxyBackendHandlerTest {
when(statement.getDatabaseName()).thenReturn("foo_db");
ShardingSphereMetaData metaData = mock(ShardingSphereMetaData.class);
when(metaData.containsDatabase("foo_db")).thenReturn(true);
- assertThrows(DatabaseCreateExistsException.class, () -> new
CreateDatabaseProxyBackendHandler(statement, metaData).execute());
+ assertThrows(DatabaseCreateExistsException.class, () -> new
CreateDatabaseProxyBackendHandler(statement, metaData, mock()).execute());
}
@Test
void assertExecuteCreateExistDatabaseWithIfNotExists() throws SQLException
{
when(statement.getDatabaseName()).thenReturn("foo_db");
when(statement.isIfNotExists()).thenReturn(true);
- assertThat(new CreateDatabaseProxyBackendHandler(statement,
mock()).execute(), isA(UpdateResponseHeader.class));
+ assertThat(new CreateDatabaseProxyBackendHandler(statement, mock(),
mock()).execute(), isA(UpdateResponseHeader.class));
}
}
diff --git
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/database/type/DropDatabaseProxyBackendHandlerTest.java
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/database/type/DropDatabaseProxyBackendHandlerTest.java
index 92267fc4fa8..096f093644d 100644
---
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/database/type/DropDatabaseProxyBackendHandlerTest.java
+++
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/database/type/DropDatabaseProxyBackendHandlerTest.java
@@ -24,18 +24,16 @@ import
org.apache.shardingsphere.infra.metadata.ShardingSphereMetaData;
import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import org.apache.shardingsphere.infra.metadata.database.rule.RuleMetaData;
import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
-import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
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.statement.core.statement.type.ddl.database.DropDatabaseStatement;
-import org.apache.shardingsphere.test.infra.framework.mock.AutoMockExtension;
-import org.apache.shardingsphere.test.infra.framework.mock.StaticMockSettings;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Answers;
import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
@@ -53,8 +51,7 @@ import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-@ExtendWith(AutoMockExtension.class)
-@StaticMockSettings(ProxyContext.class)
+@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class DropDatabaseProxyBackendHandlerTest {
@@ -69,7 +66,7 @@ class DropDatabaseProxyBackendHandlerTest {
@BeforeEach
void setUp() {
when(connectionSession.getConnectionContext().getGrantee()).thenReturn(null);
- handler = new DropDatabaseProxyBackendHandler(sqlStatement,
mockMetaData(), connectionSession);
+ handler = new DropDatabaseProxyBackendHandler(sqlStatement,
mockMetaData(), mock(), connectionSession);
}
private ShardingSphereMetaData mockMetaData() {
diff --git
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/DistSQLProxyBackendHandlerFactoryTest.java
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/DistSQLProxyBackendHandlerFactoryTest.java
index 058184b69a7..cae0b4d9483 100644
---
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/DistSQLProxyBackendHandlerFactoryTest.java
+++
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/DistSQLProxyBackendHandlerFactoryTest.java
@@ -31,7 +31,6 @@ import
org.apache.shardingsphere.infra.util.props.PropertiesBuilder.Property;
import org.apache.shardingsphere.mode.manager.ContextManager;
import org.apache.shardingsphere.mode.metadata.MetaDataContexts;
import
org.apache.shardingsphere.mode.persist.service.MetaDataManagerPersistService;
-import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
import
org.apache.shardingsphere.proxy.backend.response.header.query.QueryResponseHeader;
import
org.apache.shardingsphere.proxy.backend.response.header.update.UpdateResponseHeader;
import org.apache.shardingsphere.proxy.backend.session.ConnectionSession;
@@ -51,13 +50,12 @@ import
org.apache.shardingsphere.shadow.distsql.statement.ShowShadowTableRulesSt
import org.apache.shardingsphere.shadow.rule.ShadowRule;
import
org.apache.shardingsphere.sharding.distsql.statement.CreateShardingTableRuleStatement;
import
org.apache.shardingsphere.sql.parser.statement.core.statement.attribute.SQLStatementAttributes;
-import org.apache.shardingsphere.test.infra.framework.mock.AutoMockExtension;
-import org.apache.shardingsphere.test.infra.framework.mock.StaticMockSettings;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Answers;
import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
@@ -73,20 +71,19 @@ import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-@ExtendWith(AutoMockExtension.class)
-@StaticMockSettings(ProxyContext.class)
+@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class DistSQLProxyBackendHandlerFactoryTest {
+ private ContextManager contextManager;
+
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private ConnectionSession connectionSession;
@BeforeEach
void setUp() {
ShardingSphereDatabase database = mockDatabase();
- ContextManager contextManager = mockContextManager(database);
-
when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
-
when(ProxyContext.getInstance().databaseExists("foo_db")).thenReturn(true);
+ contextManager = mockContextManager(database);
when(connectionSession.getUsedDatabaseName()).thenReturn("foo_db");
}
@@ -117,132 +114,141 @@ class DistSQLProxyBackendHandlerFactoryTest {
void assertExecuteDataSourcesContext() throws SQLException {
RegisterStorageUnitStatement sqlStatement =
mock(RegisterStorageUnitStatement.class);
when(sqlStatement.getAttributes()).thenReturn(new
SQLStatementAttributes());
- assertThat(new DistSQLUpdateProxyBackendHandler(sqlStatement,
connectionSession).execute(), isA(UpdateResponseHeader.class));
+ assertThat(new DistSQLUpdateProxyBackendHandler(sqlStatement,
connectionSession, contextManager).execute(), isA(UpdateResponseHeader.class));
}
@Test
void assertExecuteShardingTableRuleContext() throws SQLException {
-
when(ProxyContext.getInstance().getContextManager().getDatabase("foo_db").getRuleMetaData()).thenReturn(new
RuleMetaData(Collections.emptyList()));
+
when(contextManager.getDatabase("foo_db").getRuleMetaData()).thenReturn(new
RuleMetaData(Collections.emptyList()));
CreateShardingTableRuleStatement sqlStatement =
mock(CreateShardingTableRuleStatement.class);
when(sqlStatement.getAttributes()).thenReturn(new
SQLStatementAttributes());
- assertThat(new DistSQLUpdateProxyBackendHandler(sqlStatement,
connectionSession).execute(), isA(UpdateResponseHeader.class));
+ assertThat(new DistSQLUpdateProxyBackendHandler(sqlStatement,
connectionSession, contextManager).execute(), isA(UpdateResponseHeader.class));
}
@Test
void assertExecuteAddResourceContext() throws SQLException {
RegisterStorageUnitStatement sqlStatement =
mock(RegisterStorageUnitStatement.class);
when(sqlStatement.getAttributes()).thenReturn(new
SQLStatementAttributes());
- assertThat(new DistSQLUpdateProxyBackendHandler(sqlStatement,
connectionSession).execute(), isA(UpdateResponseHeader.class));
+ assertThat(new DistSQLUpdateProxyBackendHandler(sqlStatement,
connectionSession, contextManager).execute(), isA(UpdateResponseHeader.class));
}
@Test
void assertExecuteAlterResourceContext() throws SQLException {
AlterStorageUnitStatement sqlStatement =
mock(AlterStorageUnitStatement.class);
when(sqlStatement.getAttributes()).thenReturn(new
SQLStatementAttributes());
- assertThat(new DistSQLUpdateProxyBackendHandler(sqlStatement,
connectionSession).execute(), isA(UpdateResponseHeader.class));
+ assertThat(new DistSQLUpdateProxyBackendHandler(sqlStatement,
connectionSession, contextManager).execute(), isA(UpdateResponseHeader.class));
}
@Test
void assertExecuteAlterShadowRuleContext() throws SQLException {
- mockRuleMetaData();
+ ShardingSphereDatabase database = mockDatabaseWithRule();
+ when(contextManager.getDatabase("foo_db")).thenReturn(database);
AlterShadowRuleStatement sqlStatement =
mock(AlterShadowRuleStatement.class);
when(sqlStatement.getAttributes()).thenReturn(new
SQLStatementAttributes());
- assertThat(new DistSQLUpdateProxyBackendHandler(sqlStatement,
connectionSession).execute(), isA(UpdateResponseHeader.class));
+ assertThat(new DistSQLUpdateProxyBackendHandler(sqlStatement,
connectionSession, contextManager).execute(), isA(UpdateResponseHeader.class));
}
@Test
void assertExecuteCreateShadowRuleContext() throws SQLException {
- mockRuleMetaData();
+ ShardingSphereDatabase database = mockDatabaseWithRule();
+ when(contextManager.getDatabase("foo_db")).thenReturn(database);
CreateShadowRuleStatement sqlStatement =
mock(CreateShadowRuleStatement.class);
when(sqlStatement.getAttributes()).thenReturn(new
SQLStatementAttributes());
- assertThat(new DistSQLUpdateProxyBackendHandler(sqlStatement,
connectionSession).execute(), isA(UpdateResponseHeader.class));
+ assertThat(new DistSQLUpdateProxyBackendHandler(sqlStatement,
connectionSession, contextManager).execute(), isA(UpdateResponseHeader.class));
}
@Test
void assertExecuteDropShadowRuleContext() throws SQLException {
- mockRuleMetaData();
+ ShardingSphereDatabase database = mockDatabaseWithRule();
+ when(contextManager.getDatabase("foo_db")).thenReturn(database);
DropShadowRuleStatement sqlStatement =
mock(DropShadowRuleStatement.class);
when(sqlStatement.getAttributes()).thenReturn(new
SQLStatementAttributes());
- assertThat(new DistSQLUpdateProxyBackendHandler(sqlStatement,
connectionSession).execute(), isA(UpdateResponseHeader.class));
+ assertThat(new DistSQLUpdateProxyBackendHandler(sqlStatement,
connectionSession, contextManager).execute(), isA(UpdateResponseHeader.class));
}
@Test
void assertExecuteAlterDefaultShadowAlgorithm() throws SQLException {
- mockRuleMetaData();
+ ShardingSphereDatabase database = mockDatabaseWithRule();
+ when(contextManager.getDatabase("foo_db")).thenReturn(database);
AlterDefaultShadowAlgorithmStatement statement = new
AlterDefaultShadowAlgorithmStatement(
new ShadowAlgorithmSegment("foo", new
AlgorithmSegment("SQL_HINT", PropertiesBuilder.build(new Property("type",
"value")))));
- assertThat(new DistSQLUpdateProxyBackendHandler(statement,
connectionSession).execute(), isA(UpdateResponseHeader.class));
+ assertThat(new DistSQLUpdateProxyBackendHandler(statement,
connectionSession, contextManager).execute(), isA(UpdateResponseHeader.class));
}
@Test
void assertExecuteShowShadowRulesContext() throws SQLException {
- mockRuleMetaData();
- assertThat(new
DistSQLQueryProxyBackendHandler(mock(ShowShadowRulesStatement.class,
RETURNS_DEEP_STUBS), mock(), connectionSession).execute(),
isA(QueryResponseHeader.class));
+ ShardingSphereDatabase database = mockDatabaseWithRule();
+ when(contextManager.getDatabase("foo_db")).thenReturn(database);
+ assertThat(new
DistSQLQueryProxyBackendHandler(mock(ShowShadowRulesStatement.class,
RETURNS_DEEP_STUBS), mock(), connectionSession, contextManager).execute(),
isA(QueryResponseHeader.class));
}
@Test
void assertExecuteShowShadowTableRulesContext() throws SQLException {
- mockRuleMetaData();
+ mockDatabaseWithRule();
ShowShadowTableRulesStatement sqlStatement =
mock(ShowShadowTableRulesStatement.class);
when(sqlStatement.getAttributes()).thenReturn(new
SQLStatementAttributes());
- assertThat(new DistSQLQueryProxyBackendHandler(sqlStatement, mock(),
connectionSession).execute(), isA(QueryResponseHeader.class));
+ assertThat(new DistSQLQueryProxyBackendHandler(sqlStatement, mock(),
connectionSession, contextManager).execute(), isA(QueryResponseHeader.class));
}
@Test
void assertExecuteShowShadowAlgorithmsContext() throws SQLException {
- mockRuleMetaData();
+ ShardingSphereDatabase database = mockDatabaseWithRule();
+ when(contextManager.getDatabase("foo_db")).thenReturn(database);
ShowShadowAlgorithmsStatement sqlStatement =
mock(ShowShadowAlgorithmsStatement.class);
when(sqlStatement.getAttributes()).thenReturn(new
SQLStatementAttributes());
- assertThat(new DistSQLQueryProxyBackendHandler(sqlStatement, mock(),
connectionSession).execute(), isA(QueryResponseHeader.class));
+ assertThat(new DistSQLQueryProxyBackendHandler(sqlStatement, mock(),
connectionSession, contextManager).execute(), isA(QueryResponseHeader.class));
}
@Test
void assertExecuteDropShadowAlgorithmContext() throws SQLException {
- mockRuleMetaData();
+ ShardingSphereDatabase database = mockDatabaseWithRule();
+ when(contextManager.getDatabase("foo_db")).thenReturn(database);
DropShadowAlgorithmStatement sqlStatement =
mock(DropShadowAlgorithmStatement.class);
when(sqlStatement.getAttributes()).thenReturn(new
SQLStatementAttributes());
- assertThat(new DistSQLUpdateProxyBackendHandler(sqlStatement,
connectionSession).execute(), isA(UpdateResponseHeader.class));
+ assertThat(new DistSQLUpdateProxyBackendHandler(sqlStatement,
connectionSession, contextManager).execute(), isA(UpdateResponseHeader.class));
}
@Test
void assertExecuteDropResourceContext() throws SQLException {
UnregisterStorageUnitStatement sqlStatement =
mock(UnregisterStorageUnitStatement.class);
when(sqlStatement.getAttributes()).thenReturn(new
SQLStatementAttributes());
- assertThat(new DistSQLUpdateProxyBackendHandler(sqlStatement,
connectionSession).execute(), isA(UpdateResponseHeader.class));
+ assertThat(new DistSQLUpdateProxyBackendHandler(sqlStatement,
connectionSession, contextManager).execute(), isA(UpdateResponseHeader.class));
}
@Test
void assertExecuteDropReadwriteSplittingRuleContext() {
- assertThrows(MissingRequiredRuleException.class, () -> new
DistSQLUpdateProxyBackendHandler(mock(DropReadwriteSplittingRuleStatement.class,
RETURNS_DEEP_STUBS), connectionSession).execute());
+ assertThrows(MissingRequiredRuleException.class,
+ () -> new
DistSQLUpdateProxyBackendHandler(mock(DropReadwriteSplittingRuleStatement.class,
RETURNS_DEEP_STUBS), connectionSession, contextManager).execute());
}
@Test
void assertExecuteCreateReadwriteSplittingRuleContext() throws
SQLException {
CreateReadwriteSplittingRuleStatement sqlStatement =
mock(CreateReadwriteSplittingRuleStatement.class);
when(sqlStatement.getAttributes()).thenReturn(new
SQLStatementAttributes());
- assertThat(new DistSQLUpdateProxyBackendHandler(sqlStatement,
connectionSession).execute(), isA(UpdateResponseHeader.class));
+ assertThat(new DistSQLUpdateProxyBackendHandler(sqlStatement,
connectionSession, contextManager).execute(), isA(UpdateResponseHeader.class));
}
@Test
void assertExecuteAlterReadwriteSplittingRuleContext() {
- assertThrows(MissingRequiredRuleException.class, () -> new
DistSQLUpdateProxyBackendHandler(mock(AlterReadwriteSplittingRuleStatement.class,
RETURNS_DEEP_STUBS), connectionSession).execute());
+ assertThrows(MissingRequiredRuleException.class,
+ () -> new
DistSQLUpdateProxyBackendHandler(mock(AlterReadwriteSplittingRuleStatement.class,
RETURNS_DEEP_STUBS), connectionSession, contextManager).execute());
}
- private void mockRuleMetaData() {
- ShardingSphereDatabase database = mock(ShardingSphereDatabase.class,
RETURNS_DEEP_STUBS);
- when(database.getName()).thenReturn("foo_db");
-
when(database.getResourceMetaData()).thenReturn(mock(ResourceMetaData.class));
+ private ShardingSphereDatabase mockDatabaseWithRule() {
+ ShardingSphereDatabase result = mock(ShardingSphereDatabase.class,
RETURNS_DEEP_STUBS);
+ when(result.getName()).thenReturn("foo_db");
+
when(result.getResourceMetaData()).thenReturn(mock(ResourceMetaData.class));
RuleMetaData ruleMetaData = mock(RuleMetaData.class);
- ShadowRuleConfiguration ruleConfig = mockShadowRuleConfiguration();
+ ShadowRuleConfiguration ruleConfig = createShadowRuleConfiguration();
when(ruleMetaData.getConfigurations()).thenReturn(Collections.singleton(ruleConfig));
ShadowRule rule = mock(ShadowRule.class);
when(rule.getConfiguration()).thenReturn(ruleConfig);
when(ruleMetaData.findSingleRule(ShadowRule.class)).thenReturn(Optional.of(rule));
- when(database.getRuleMetaData()).thenReturn(ruleMetaData);
-
when(ProxyContext.getInstance().getContextManager().getDatabase("foo_db")).thenReturn(database);
+ when(result.getRuleMetaData()).thenReturn(ruleMetaData);
+ return result;
}
- private ShadowRuleConfiguration mockShadowRuleConfiguration() {
+ private ShadowRuleConfiguration createShadowRuleConfiguration() {
ShadowRuleConfiguration result = new ShadowRuleConfiguration();
result.getShadowAlgorithms().put("default_shadow_algorithm",
mock(AlgorithmConfiguration.class));
return result;
diff --git
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/DistSQLQueryProxyBackendHandlerTest.java
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/DistSQLQueryProxyBackendHandlerTest.java
index ed065e63e93..71c392051da 100644
---
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/DistSQLQueryProxyBackendHandlerTest.java
+++
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/DistSQLQueryProxyBackendHandlerTest.java
@@ -64,8 +64,8 @@ class DistSQLQueryProxyBackendHandlerTest {
@Test
void assertExecuteWithNoDatabase() {
- assertThrows(NoDatabaseSelectedException.class,
- () -> new
DistSQLQueryProxyBackendHandler(mock(ExportDatabaseConfigurationStatement.class,
RETURNS_DEEP_STUBS), mock(), mock(ConnectionSession.class,
RETURNS_DEEP_STUBS)).execute());
+ assertThrows(NoDatabaseSelectedException.class, () -> new
DistSQLQueryProxyBackendHandler(
+ mock(ExportDatabaseConfigurationStatement.class,
RETURNS_DEEP_STUBS), mock(), mock(ConnectionSession.class, RETURNS_DEEP_STUBS),
mock()).execute());
}
@Test
@@ -77,23 +77,23 @@ class DistSQLQueryProxyBackendHandlerTest {
ComputeNodeInstanceContext computeNodeInstanceContext =
mock(ComputeNodeInstanceContext.class);
when(computeNodeInstanceContext.getModeConfiguration()).thenReturn(mock(ModeConfiguration.class));
ContextManager contextManager = new ContextManager(metaDataContexts,
computeNodeInstanceContext, mock(), mock(PersistRepository.class));
-
when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
assertThrows(UnknownDatabaseException.class,
- () -> new
DistSQLQueryProxyBackendHandler(mock(ExportDatabaseConfigurationStatement.class,
RETURNS_DEEP_STUBS), mock(), connectionSession).execute());
+ () -> new
DistSQLQueryProxyBackendHandler(mock(ExportDatabaseConfigurationStatement.class,
RETURNS_DEEP_STUBS), mock(), connectionSession, contextManager).execute());
}
@Test
void assertExecuteWithAbstractStatement() {
assertThrows(ServiceProviderNotFoundException.class,
- () -> new
DistSQLQueryProxyBackendHandler(mock(QueryableRALStatement.class,
RETURNS_DEEP_STUBS), mock(), mock(ConnectionSession.class,
RETURNS_DEEP_STUBS)).execute());
+ () -> new
DistSQLQueryProxyBackendHandler(mock(QueryableRALStatement.class,
RETURNS_DEEP_STUBS), mock(), mock(ConnectionSession.class, RETURNS_DEEP_STUBS),
mock()).execute());
}
@Test
void assertExecute() {
ShardingSphereDatabase database = new ShardingSphereDatabase(
"foo_db", databaseType, mock(), mock(),
Collections.singleton(new ShardingSphereSchema("foo_db", createTables(),
Collections.emptyList())));
-
when(ProxyContext.getInstance().getContextManager().getDatabase("foo_db")).thenReturn(database);
- assertDoesNotThrow(() -> new
DistSQLQueryProxyBackendHandler(createSqlStatement(), mock(),
mock(ConnectionSession.class, RETURNS_DEEP_STUBS)).execute());
+ ContextManager contextManager = mock(ContextManager.class);
+ when(contextManager.getDatabase("foo_db")).thenReturn(database);
+ assertDoesNotThrow(() -> new
DistSQLQueryProxyBackendHandler(createSqlStatement(), mock(),
mock(ConnectionSession.class, RETURNS_DEEP_STUBS), contextManager).execute());
}
private Collection<ShardingSphereTable> createTables() {
diff --git
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/DistSQLUpdateProxyBackendHandlerTest.java
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/DistSQLUpdateProxyBackendHandlerTest.java
index c17f9a08c31..dc5630f22e8 100644
---
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/DistSQLUpdateProxyBackendHandlerTest.java
+++
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/DistSQLUpdateProxyBackendHandlerTest.java
@@ -29,17 +29,14 @@ import
org.apache.shardingsphere.infra.metadata.database.resource.unit.StorageUn
import
org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereSchema;
import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
import org.apache.shardingsphere.mode.manager.ContextManager;
-import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
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.infra.framework.mock.AutoMockExtension;
-import org.apache.shardingsphere.test.infra.framework.mock.StaticMockSettings;
-import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Answers;
import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
import java.sql.SQLException;
import java.util.Collections;
@@ -51,8 +48,7 @@ import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-@ExtendWith(AutoMockExtension.class)
-@StaticMockSettings(ProxyContext.class)
+@ExtendWith(MockitoExtension.class)
class DistSQLUpdateProxyBackendHandlerTest {
private final DatabaseType databaseType =
TypedSPILoader.getService(DatabaseType.class, "FIXTURE");
@@ -60,15 +56,10 @@ class DistSQLUpdateProxyBackendHandlerTest {
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private ContextManager contextManager;
- @BeforeEach
- void setUp() {
-
when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
- }
-
@Test
void assertEmptyStorageUnit() {
when(contextManager.getDatabase("foo_db")).thenReturn(new
ShardingSphereDatabase("foo_db", databaseType, mock(), mock(),
Collections.emptyList()));
- DistSQLUpdateProxyBackendHandler backendHandler = new
DistSQLUpdateProxyBackendHandler(new RefreshTableMetaDataStatement(),
mockConnectionSession("foo_db"));
+ DistSQLUpdateProxyBackendHandler backendHandler = new
DistSQLUpdateProxyBackendHandler(new RefreshTableMetaDataStatement(),
mockConnectionSession("foo_db"), contextManager);
assertThrows(EmptyStorageUnitException.class, backendHandler::execute);
}
@@ -77,7 +68,8 @@ class DistSQLUpdateProxyBackendHandlerTest {
ResourceMetaData resourceMetaData = mock(ResourceMetaData.class);
when(resourceMetaData.getStorageUnits()).thenReturn(Collections.singletonMap("ds_0",
mock(StorageUnit.class)));
when(contextManager.getDatabase("foo_db")).thenReturn(new
ShardingSphereDatabase("foo_db", databaseType, resourceMetaData, mock(),
Collections.emptyList()));
- DistSQLUpdateProxyBackendHandler backendHandler = new
DistSQLUpdateProxyBackendHandler(new RefreshTableMetaDataStatement("t_order",
"ds_1", null), mockConnectionSession("foo_db"));
+ DistSQLUpdateProxyBackendHandler backendHandler = new
DistSQLUpdateProxyBackendHandler(
+ new RefreshTableMetaDataStatement("t_order", "ds_1", null),
mockConnectionSession("foo_db"), contextManager);
assertThrows(MissingRequiredStorageUnitsException.class,
backendHandler::execute);
}
@@ -86,7 +78,8 @@ class DistSQLUpdateProxyBackendHandlerTest {
ResourceMetaData resourceMetaData = mock(ResourceMetaData.class);
when(resourceMetaData.getStorageUnits()).thenReturn(Collections.singletonMap("ds_0",
mock(StorageUnit.class)));
when(contextManager.getDatabase("foo_db")).thenReturn(new
ShardingSphereDatabase("foo_db", databaseType, resourceMetaData, mock(),
Collections.emptyList()));
- DistSQLUpdateProxyBackendHandler backendHandler = new
DistSQLUpdateProxyBackendHandler(new RefreshTableMetaDataStatement("t_order",
"ds_0", "bar_db"), mockConnectionSession("foo_db"));
+ DistSQLUpdateProxyBackendHandler backendHandler = new
DistSQLUpdateProxyBackendHandler(
+ new RefreshTableMetaDataStatement("t_order", "ds_0",
"bar_db"), mockConnectionSession("foo_db"), contextManager);
assertThrows(SchemaNotFoundException.class, backendHandler::execute);
}
@@ -100,7 +93,8 @@ class DistSQLUpdateProxyBackendHandlerTest {
when(database.getSchema("foo_db")).thenReturn(schema);
when(database.getResourceMetaData()).thenReturn(resourceMetaData);
when(contextManager.getDatabase("foo_db")).thenReturn(database);
- DistSQLUpdateProxyBackendHandler backendHandler = new
DistSQLUpdateProxyBackendHandler(new RefreshTableMetaDataStatement("t_order",
"ds_0", "foo_db"), mockConnectionSession("foo_db"));
+ DistSQLUpdateProxyBackendHandler backendHandler = new
DistSQLUpdateProxyBackendHandler(
+ new RefreshTableMetaDataStatement("t_order", "ds_0",
"foo_db"), mockConnectionSession("foo_db"), contextManager);
assertThrows(TableNotFoundException.class, backendHandler::execute);
}
@@ -113,7 +107,7 @@ class DistSQLUpdateProxyBackendHandlerTest {
when(database.getProtocolType()).thenReturn(databaseType);
when(database.getResourceMetaData()).thenReturn(resourceMetaData);
when(contextManager.getDatabase("foo_db")).thenReturn(database);
- ResponseHeader actual = new DistSQLUpdateProxyBackendHandler(new
RefreshTableMetaDataStatement(), mockConnectionSession("foo_db")).execute();
+ ResponseHeader actual = new DistSQLUpdateProxyBackendHandler(new
RefreshTableMetaDataStatement(), mockConnectionSession("foo_db"),
contextManager).execute();
assertThat(actual, isA(UpdateResponseHeader.class));
}
diff --git
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rul/ParseDistSQLExecutorTest.java
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rul/ParseDistSQLExecutorTest.java
index 0526519f035..9c79777b43e 100644
---
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rul/ParseDistSQLExecutorTest.java
+++
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rul/ParseDistSQLExecutorTest.java
@@ -26,17 +26,15 @@ import org.apache.shardingsphere.infra.util.json.JsonUtils;
import org.apache.shardingsphere.mode.manager.ContextManager;
import org.apache.shardingsphere.parser.rule.SQLParserRule;
import
org.apache.shardingsphere.parser.rule.builder.DefaultSQLParserRuleConfigurationBuilder;
-import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
import
org.apache.shardingsphere.proxy.backend.handler.distsql.DistSQLQueryProxyBackendHandler;
import org.apache.shardingsphere.proxy.backend.session.ConnectionSession;
import
org.apache.shardingsphere.sql.parser.statement.core.statement.SQLStatement;
-import org.apache.shardingsphere.test.infra.framework.mock.AutoMockExtension;
-import org.apache.shardingsphere.test.infra.framework.mock.StaticMockSettings;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Answers;
import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
import java.sql.SQLException;
import java.util.Collections;
@@ -48,8 +46,7 @@ import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-@ExtendWith(AutoMockExtension.class)
-@StaticMockSettings(ProxyContext.class)
+@ExtendWith(MockitoExtension.class)
class ParseDistSQLExecutorTest {
private final SQLParserRule sqlParserRule = new SQLParserRule(new
DefaultSQLParserRuleConfigurationBuilder().build());
@@ -63,14 +60,13 @@ class ParseDistSQLExecutorTest {
@BeforeEach
void setUp() {
when(contextManager.getMetaDataContexts().getMetaData().getGlobalRuleMetaData()).thenReturn(new
RuleMetaData(Collections.singleton(sqlParserRule)));
-
when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
}
@Test
void assertGetRowDataForMySQL() throws SQLException {
String sql = "SELECT * FROM t_order";
when(connectionSession.getProtocolType()).thenReturn(TypedSPILoader.getService(DatabaseType.class,
"MySQL"));
- DistSQLQueryProxyBackendHandler handler = new
DistSQLQueryProxyBackendHandler(new ParseStatement(sql), mock(),
connectionSession);
+ DistSQLQueryProxyBackendHandler handler = new
DistSQLQueryProxyBackendHandler(new ParseStatement(sql), mock(),
connectionSession, contextManager);
handler.execute();
handler.next();
SQLStatement sqlStatement =
sqlParserRule.getSQLParserEngine(TypedSPILoader.getService(DatabaseType.class,
"MySQL")).parse(sql, false);
@@ -82,7 +78,7 @@ class ParseDistSQLExecutorTest {
void assertGetRowDataForPostgreSQL() throws SQLException {
String sql = "SELECT * FROM t_order";
when(connectionSession.getProtocolType()).thenReturn(TypedSPILoader.getService(DatabaseType.class,
"PostgreSQL"));
- DistSQLQueryProxyBackendHandler handler = new
DistSQLQueryProxyBackendHandler(new ParseStatement(sql), mock(),
connectionSession);
+ DistSQLQueryProxyBackendHandler handler = new
DistSQLQueryProxyBackendHandler(new ParseStatement(sql), mock(),
connectionSession, contextManager);
handler.execute();
handler.next();
SQLStatement sqlStatement =
sqlParserRule.getSQLParserEngine(TypedSPILoader.getService(DatabaseType.class,
"PostgreSQL")).parse(sql, false);
@@ -93,7 +89,7 @@ class ParseDistSQLExecutorTest {
void assertExecute() {
String sql = "wrong sql";
when(connectionSession.getProtocolType()).thenReturn(TypedSPILoader.getService(DatabaseType.class,
"MySQL"));
- DistSQLQueryProxyBackendHandler handler = new
DistSQLQueryProxyBackendHandler(new ParseStatement(sql), mock(),
connectionSession);
+ DistSQLQueryProxyBackendHandler handler = new
DistSQLQueryProxyBackendHandler(new ParseStatement(sql), mock(),
connectionSession, contextManager);
assertThrows(DialectSQLParsingException.class, handler::execute);
}
}
