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 a645ee55eb1 Remove ProxyContextRestorer on front-postgresql module
(#24323)
a645ee55eb1 is described below
commit a645ee55eb1623fd74f74393c47c51d75da3d971
Author: Liang Zhang <[email protected]>
AuthorDate: Thu Feb 23 20:37:16 2023 +0800
Remove ProxyContextRestorer on front-postgresql module (#24323)
* Remove ProxyContextRestorer on PortalTest
* Remove ProxyContextRestorer on
PostgreSQLAggregatedBatchedStatementsCommandExecutorTest
* Remove ProxyContextRestorer on PostgreSQLCommandExecuteEngineTest
* Remove ProxyContextRestorer on PostgreSQLComBindExecutorTest
* Remove ProxyContextRestorer on PostgreSQLBatchedStatementsExecutorTest
* Remove ProxyContextRestorer on PostgreSQLAuthenticationEngineTest
* Remove ProxyContextRestorer on PostgreSQLComParseExecutorTest
* Remove ProxyContextRestorer on PostgreSQLComDescribeExecutorTest
* for checkstyle
* for checkstyle
---
.../frontend/postgresql/ProxyContextRestorer.java | 38 ----
.../PostgreSQLAuthenticationEngineTest.java | 70 +++---
.../PostgreSQLCommandExecuteEngineTest.java | 22 +-
.../command/query/extended/PortalTest.java | 49 +++--
...egatedBatchedStatementsCommandExecutorTest.java | 91 ++++----
.../PostgreSQLBatchedStatementsExecutorTest.java | 102 +++++----
.../bind/PostgreSQLComBindExecutorTest.java | 30 ++-
.../PostgreSQLComDescribeExecutorTest.java | 239 ++++++++++++---------
.../parse/PostgreSQLComParseExecutorTest.java | 99 ++++-----
9 files changed, 390 insertions(+), 350 deletions(-)
diff --git
a/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/ProxyContextRestorer.java
b/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/ProxyContextRestorer.java
deleted file mode 100644
index 43691bca3bc..00000000000
---
a/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/ProxyContextRestorer.java
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.shardingsphere.proxy.frontend.postgresql;
-
-import org.apache.shardingsphere.mode.manager.ContextManager;
-import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
-import org.junit.After;
-import org.junit.Before;
-
-public abstract class ProxyContextRestorer {
-
- private ContextManager currentContextManager;
-
- @Before
- public void recordCurrentContextManager() {
- currentContextManager = ProxyContext.getInstance().getContextManager();
- }
-
- @After
- public void restorePreviousContextManager() {
- ProxyContext.init(currentContextManager);
- }
-}
diff --git
a/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/authentication/PostgreSQLAuthenticationEngineTest.java
b/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/authentication/PostgreSQLAuthenticationEngineTest.java
index ecfef45693f..b81d4949cb4 100644
---
a/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/authentication/PostgreSQLAuthenticationEngineTest.java
+++
b/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/authentication/PostgreSQLAuthenticationEngineTest.java
@@ -43,7 +43,6 @@ import
org.apache.shardingsphere.mode.metadata.MetaDataContexts;
import org.apache.shardingsphere.mode.metadata.persist.MetaDataPersistService;
import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
import
org.apache.shardingsphere.proxy.frontend.authentication.AuthenticationResult;
-import
org.apache.shardingsphere.proxy.frontend.postgresql.ProxyContextRestorer;
import
org.apache.shardingsphere.proxy.frontend.postgresql.authentication.authenticator.impl.PostgreSQLMD5PasswordAuthenticator;
import org.junit.Before;
import org.junit.Test;
@@ -51,6 +50,7 @@ import org.junit.runner.RunWith;
import org.mockito.Answers;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
+import org.mockito.MockedStatic;
import org.mockito.internal.configuration.plugins.Plugins;
import org.mockito.junit.MockitoJUnitRunner;
@@ -64,11 +64,12 @@ import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertFalse;
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.verify;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
-public final class PostgreSQLAuthenticationEngineTest extends
ProxyContextRestorer {
+public final class PostgreSQLAuthenticationEngineTest {
private final String username = "root";
@@ -81,13 +82,6 @@ public final class PostgreSQLAuthenticationEngineTest
extends ProxyContextRestor
@Before
public void setup() {
when(channelHandlerContext.channel().attr(CommonConstants.CHARSET_ATTRIBUTE_KEY)).thenReturn(mock(Attribute.class));
- mockInitProxyContext();
- }
-
- private void mockInitProxyContext() {
- ContextManager contextManager = mock(ContextManager.class,
RETURNS_DEEP_STUBS);
-
when(contextManager.getMetaDataContexts().getMetaData().getGlobalRuleMetaData()).thenReturn(new
ShardingSphereRuleMetaData(Collections.singleton(mock(AuthorityRule.class))));
- ProxyContext.init(contextManager);
}
@Test
@@ -107,7 +101,11 @@ public final class PostgreSQLAuthenticationEngineTest
extends ProxyContextRestor
payload.writeInt4(196608);
payload.writeStringNul("client_encoding");
payload.writeStringNul("UTF8");
- new
PostgreSQLAuthenticationEngine().authenticate(channelHandlerContext, payload);
+ ContextManager contextManager = mockContextManager();
+ try (MockedStatic<ProxyContext> proxyContext =
mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
+ proxyContext.when(() ->
ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ new
PostgreSQLAuthenticationEngine().authenticate(channelHandlerContext, payload);
+ }
}
@Test(expected = ProtocolViolationException.class)
@@ -117,7 +115,11 @@ public final class PostgreSQLAuthenticationEngineTest
extends ProxyContextRestor
PostgreSQLPacketPayload payload = new
PostgreSQLPacketPayload(createByteBuf(8, 16), StandardCharsets.UTF_8);
payload.writeInt1('F');
payload.writeInt8(0);
- authenticationEngine.authenticate(channelHandlerContext, payload);
+ ContextManager contextManager = mockContextManager();
+ try (MockedStatic<ProxyContext> proxyContext =
mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
+ proxyContext.when(() ->
ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ authenticationEngine.authenticate(channelHandlerContext, payload);
+ }
}
@SneakyThrows(ReflectiveOperationException.class)
@@ -145,31 +147,39 @@ public final class PostgreSQLAuthenticationEngineTest
extends ProxyContextRestor
payload.writeStringNul("client_encoding");
payload.writeStringNul("UTF8");
PostgreSQLAuthenticationEngine engine = new
PostgreSQLAuthenticationEngine();
- AuthenticationResult actual =
engine.authenticate(channelHandlerContext, payload);
- assertFalse(actual.isFinished());
- assertThat(actual.getUsername(), is(username));
- ArgumentCaptor<PostgreSQLMD5PasswordAuthenticationPacket>
argumentCaptor =
ArgumentCaptor.forClass(PostgreSQLMD5PasswordAuthenticationPacket.class);
- verify(channelHandlerContext).writeAndFlush(argumentCaptor.capture());
- PostgreSQLMD5PasswordAuthenticationPacket md5PasswordPacket =
argumentCaptor.getValue();
- byte[] md5Salt = getMd5Salt(md5PasswordPacket);
- payload = new PostgreSQLPacketPayload(createByteBuf(16, 128),
StandardCharsets.UTF_8);
- String md5Digest = (String)
Plugins.getMemberAccessor().invoke(PostgreSQLMD5PasswordAuthenticator.class.getDeclaredMethod("md5Encode",
String.class, String.class, byte[].class),
- new PostgreSQLMD5PasswordAuthenticator(), username,
inputPassword, md5Salt);
- payload.writeInt1('p');
- payload.writeInt4(4 + md5Digest.length() + 1);
- payload.writeStringNul(md5Digest);
- MetaDataContexts metaDataContexts = getMetaDataContexts(new
ShardingSphereUser(username, password, ""));
- ContextManager contextManager = mock(ContextManager.class,
RETURNS_DEEP_STUBS);
-
when(contextManager.getMetaDataContexts()).thenReturn(metaDataContexts);
- ProxyContext.init(contextManager);
- actual = engine.authenticate(channelHandlerContext, payload);
- assertThat(actual.isFinished(), is(password.equals(inputPassword)));
+ ContextManager contextManager = mockContextManager();
+ try (MockedStatic<ProxyContext> proxyContext =
mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
+ proxyContext.when(() ->
ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ AuthenticationResult actual =
engine.authenticate(channelHandlerContext, payload);
+ assertFalse(actual.isFinished());
+ assertThat(actual.getUsername(), is(username));
+ ArgumentCaptor<PostgreSQLMD5PasswordAuthenticationPacket>
argumentCaptor =
ArgumentCaptor.forClass(PostgreSQLMD5PasswordAuthenticationPacket.class);
+
verify(channelHandlerContext).writeAndFlush(argumentCaptor.capture());
+ PostgreSQLMD5PasswordAuthenticationPacket md5PasswordPacket =
argumentCaptor.getValue();
+ byte[] md5Salt = getMd5Salt(md5PasswordPacket);
+ payload = new PostgreSQLPacketPayload(createByteBuf(16, 128),
StandardCharsets.UTF_8);
+ String md5Digest = (String)
Plugins.getMemberAccessor().invoke(PostgreSQLMD5PasswordAuthenticator.class.getDeclaredMethod("md5Encode",
String.class, String.class, byte[].class),
+ new PostgreSQLMD5PasswordAuthenticator(), username,
inputPassword, md5Salt);
+ payload.writeInt1('p');
+ payload.writeInt4(4 + md5Digest.length() + 1);
+ payload.writeStringNul(md5Digest);
+ MetaDataContexts metaDataContexts = getMetaDataContexts(new
ShardingSphereUser(username, password, ""));
+
when(contextManager.getMetaDataContexts()).thenReturn(metaDataContexts);
+ actual = engine.authenticate(channelHandlerContext, payload);
+ assertThat(actual.isFinished(),
is(password.equals(inputPassword)));
+ }
}
private ByteBuf createByteBuf(final int initialCapacity, final int
maxCapacity) {
return new UnpooledHeapByteBuf(UnpooledByteBufAllocator.DEFAULT,
initialCapacity, maxCapacity);
}
+ private ContextManager mockContextManager() {
+ ContextManager result = mock(ContextManager.class, RETURNS_DEEP_STUBS);
+
when(result.getMetaDataContexts().getMetaData().getGlobalRuleMetaData()).thenReturn(new
ShardingSphereRuleMetaData(Collections.singleton(mock(AuthorityRule.class))));
+ return result;
+ }
+
private MetaDataContexts getMetaDataContexts(final ShardingSphereUser
user) {
return new MetaDataContexts(
mock(MetaDataPersistService.class), new
ShardingSphereMetaData(new LinkedHashMap<>(), buildGlobalRuleMetaData(user),
new ConfigurationProperties(new Properties())));
diff --git
a/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/PostgreSQLCommandExecuteEngineTest.java
b/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/PostgreSQLCommandExecuteEngineTest.java
index 9f6804b00cc..61aad503805 100644
---
a/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/PostgreSQLCommandExecuteEngineTest.java
+++
b/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/PostgreSQLCommandExecuteEngineTest.java
@@ -33,13 +33,13 @@ 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.proxy.frontend.command.executor.ResponseType;
-import
org.apache.shardingsphere.proxy.frontend.postgresql.ProxyContextRestorer;
import
org.apache.shardingsphere.proxy.frontend.postgresql.command.query.simple.PostgreSQLComQueryExecutor;
import org.apache.shardingsphere.transaction.api.TransactionType;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
+import org.mockito.MockedStatic;
import org.mockito.junit.MockitoJUnitRunner;
import java.sql.SQLException;
@@ -48,11 +48,12 @@ import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.isA;
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.verify;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
-public final class PostgreSQLCommandExecuteEngineTest extends
ProxyContextRestorer {
+public final class PostgreSQLCommandExecuteEngineTest {
@Mock
private ChannelHandlerContext channelHandlerContext;
@@ -68,7 +69,6 @@ public final class PostgreSQLCommandExecuteEngineTest extends
ProxyContextRestor
@Before
public void setUp() {
- ProxyContext.init(new ContextManager(new
MetaDataContexts(mock(MetaDataPersistService.class), new
ShardingSphereMetaData()), mock(InstanceContext.class)));
when(channelHandlerContext.channel()).thenReturn(channel);
when(connectionSession.getTransactionStatus()).thenReturn(new
TransactionStatus(TransactionType.LOCAL));
}
@@ -117,11 +117,15 @@ public final class PostgreSQLCommandExecuteEngineTest
extends ProxyContextRestor
PostgreSQLPacket packet = mock(PostgreSQLPacket.class);
when(queryCommandExecutor.getQueryRowPacket()).thenReturn(packet);
PostgreSQLCommandExecuteEngine commandExecuteEngine = new
PostgreSQLCommandExecuteEngine();
- commandExecuteEngine.writeQueryData(channelHandlerContext,
backendConnection, queryCommandExecutor, 0);
- verify(resourceLock).doAwait();
- verify(channelHandlerContext).write(packet);
-
verify(channelHandlerContext).write(isA(PostgreSQLCommandCompletePacket.class));
- verify(channelHandlerContext).flush();
-
verify(channelHandlerContext).write(isA(PostgreSQLReadyForQueryPacket.class));
+ ContextManager contextManager = new ContextManager(new
MetaDataContexts(mock(MetaDataPersistService.class), new
ShardingSphereMetaData()), mock(InstanceContext.class));
+ try (MockedStatic<ProxyContext> proxyContext =
mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
+ proxyContext.when(() ->
ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ commandExecuteEngine.writeQueryData(channelHandlerContext,
backendConnection, queryCommandExecutor, 0);
+ verify(resourceLock).doAwait();
+ verify(channelHandlerContext).write(packet);
+
verify(channelHandlerContext).write(isA(PostgreSQLCommandCompletePacket.class));
+ verify(channelHandlerContext).flush();
+
verify(channelHandlerContext).write(isA(PostgreSQLReadyForQueryPacket.class));
+ }
}
}
diff --git
a/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/query/extended/PortalTest.java
b/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/query/extended/PortalTest.java
index 03736dbc496..a920f666fca 100644
---
a/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/query/extended/PortalTest.java
+++
b/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/query/extended/PortalTest.java
@@ -46,7 +46,6 @@ import
org.apache.shardingsphere.proxy.backend.response.header.query.QueryHeader
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;
-import
org.apache.shardingsphere.proxy.frontend.postgresql.ProxyContextRestorer;
import
org.apache.shardingsphere.sql.parser.sql.common.segment.dal.VariableAssignSegment;
import
org.apache.shardingsphere.sql.parser.sql.common.segment.dal.VariableSegment;
import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
@@ -85,42 +84,52 @@ import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
-public final class PortalTest extends ProxyContextRestorer {
+public final class PortalTest {
- @Mock(answer = Answers.RETURNS_DEEP_STUBS)
- private ContextManager mockContextManager;
+ private MockedStatic<ProxyContext> mockedProxyContext;
- @Mock
- private ProxyBackendHandler proxyBackendHandler;
+ private MockedStatic<ProxyBackendHandlerFactory>
mockedProxyBackendHandlerFactory;
@Mock
- private ConnectionSession connectionSession;
+ private ProxyBackendHandler proxyBackendHandler;
@Mock
private BackendConnection backendConnection;
- private MockedStatic<ProxyBackendHandlerFactory> mockedStatic;
-
@Before
public void setup() {
- ProxyContext.init(mockContextManager);
-
when(mockContextManager.getMetaDataContexts().getMetaData().containsDatabase("db")).thenReturn(true);
-
when(ProxyContext.getInstance().getContextManager().getMetaDataContexts().getMetaData().getProps().getValue(ConfigurationPropertyKey.SQL_SHOW)).thenReturn(false);
+ mockedProxyContext = mockProxyContext();
+ ConnectionSession connectionSession = mock(ConnectionSession.class);
when(connectionSession.getDefaultDatabaseName()).thenReturn("db");
- ShardingSphereDatabase database = mock(ShardingSphereDatabase.class,
RETURNS_DEEP_STUBS);
- when(database.getProtocolType()).thenReturn(new
PostgreSQLDatabaseType());
-
when(ProxyContext.getInstance().getDatabase("db")).thenReturn(database);
+ mockedProxyBackendHandlerFactory =
mockProxyBackendHandlerFactory(connectionSession);
when(backendConnection.getConnectionSession()).thenReturn(connectionSession);
- mockedStatic = mockStatic(ProxyBackendHandlerFactory.class);
- mockedStatic.when(() ->
ProxyBackendHandlerFactory.newInstance(any(PostgreSQLDatabaseType.class),
anyString(), any(SQLStatement.class), eq(connectionSession),
any(HintValueContext.class)))
- .thenReturn(proxyBackendHandler);
- mockedStatic.when(() ->
ProxyBackendHandlerFactory.newInstance(any(PostgreSQLDatabaseType.class),
any(QueryContext.class), eq(connectionSession), anyBoolean()))
+ }
+
+ private MockedStatic<ProxyBackendHandlerFactory>
mockProxyBackendHandlerFactory(final ConnectionSession connectionSession) {
+ MockedStatic<ProxyBackendHandlerFactory> result =
mockStatic(ProxyBackendHandlerFactory.class);
+ result.when(() ->
ProxyBackendHandlerFactory.newInstance(any(PostgreSQLDatabaseType.class),
anyString(), any(SQLStatement.class), eq(connectionSession),
any(HintValueContext.class)))
.thenReturn(proxyBackendHandler);
+ result.when(() ->
ProxyBackendHandlerFactory.newInstance(any(PostgreSQLDatabaseType.class),
any(QueryContext.class), eq(connectionSession),
anyBoolean())).thenReturn(proxyBackendHandler);
+ return result;
+ }
+
+ private MockedStatic<ProxyContext> mockProxyContext() {
+ MockedStatic<ProxyContext> result = mockStatic(ProxyContext.class);
+ result.when(() ->
ProxyContext.getInstance()).thenReturn(mock(ProxyContext.class,
RETURNS_DEEP_STUBS));
+ ContextManager mockedContextManager = mock(ContextManager.class,
Answers.RETURNS_DEEP_STUBS);
+ result.when(() ->
ProxyContext.getInstance().getContextManager()).thenReturn(mockedContextManager);
+
when(mockedContextManager.getMetaDataContexts().getMetaData().containsDatabase("db")).thenReturn(true);
+
when(mockedContextManager.getMetaDataContexts().getMetaData().getProps().getValue(ConfigurationPropertyKey.SQL_SHOW)).thenReturn(false);
+ ShardingSphereDatabase database = mock(ShardingSphereDatabase.class);
+ when(database.getProtocolType()).thenReturn(new
PostgreSQLDatabaseType());
+ result.when(() ->
ProxyContext.getInstance().getDatabase("db")).thenReturn(database);
+ return result;
}
@After
public void tearDown() {
- mockedStatic.close();
+ mockedProxyContext.close();
+ mockedProxyBackendHandlerFactory.close();
}
@Test
diff --git
a/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/query/extended/PostgreSQLAggregatedBatchedStatementsCommandExecutorTest.java
b/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/query/extended/PostgreSQLAggregatedBatchedStatementsCommandExecutorTest.java
index 7e8d9280af7..99d7b8ed091 100644
---
a/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/query/extended/PostgreSQLAggregatedBatchedStatementsCommandExecutorTest.java
+++
b/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/query/extended/PostgreSQLAggregatedBatchedStatementsCommandExecutorTest.java
@@ -46,13 +46,11 @@ import
org.apache.shardingsphere.proxy.backend.connector.jdbc.statement.JDBCBack
import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
import org.apache.shardingsphere.proxy.backend.session.ConnectionSession;
import
org.apache.shardingsphere.proxy.backend.session.ServerPreparedStatementRegistry;
-import
org.apache.shardingsphere.proxy.frontend.postgresql.ProxyContextRestorer;
import org.apache.shardingsphere.sql.parser.api.CacheOption;
-import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
import org.apache.shardingsphere.sqltranslator.rule.SQLTranslatorRule;
import
org.apache.shardingsphere.sqltranslator.rule.builder.DefaultSQLTranslatorRuleConfigurationBuilder;
-import org.junit.Before;
import org.junit.Test;
+import org.mockito.MockedStatic;
import java.sql.Connection;
import java.sql.PreparedStatement;
@@ -70,9 +68,10 @@ import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.nullable;
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;
-public final class PostgreSQLAggregatedBatchedStatementsCommandExecutorTest
extends ProxyContextRestorer {
+public final class PostgreSQLAggregatedBatchedStatementsCommandExecutorTest {
private static final ShardingSphereSQLParserEngine SQL_PARSER_ENGINE = new
ShardingSphereSQLParserEngine("PostgreSQL", new CacheOption(2000, 65535L), new
CacheOption(128, 1024L), false);
@@ -80,39 +79,38 @@ public final class
PostgreSQLAggregatedBatchedStatementsCommandExecutorTest exte
private static final String STATEMENT_ID = "S_1";
- private static final String SQL = "insert into t_order (id) values (?)";
+ private static final String SQL = "INSERT INTO t_order (id) VALUES (?)";
private static final int BATCH_SIZE = 10;
- @Before
- public void setup() {
- ProxyContext.init(mock(ContextManager.class, RETURNS_DEEP_STUBS));
- }
-
- @SuppressWarnings("rawtypes")
@Test
public void assertExecute() throws SQLException {
-
when(ProxyContext.getInstance().getContextManager().getMetaDataContexts().getMetaData().getProps().<Integer>getValue(ConfigurationPropertyKey.KERNEL_EXECUTOR_SIZE)).thenReturn(0);
-
when(ProxyContext.getInstance().getContextManager().getMetaDataContexts().getMetaData().getProps().<Integer>getValue(ConfigurationPropertyKey.MAX_CONNECTIONS_SIZE_PER_QUERY)).thenReturn(1);
-
when(ProxyContext.getInstance().getContextManager().getMetaDataContexts().getMetaData().getProps().<Boolean>getValue(ConfigurationPropertyKey.SQL_SHOW)).thenReturn(false);
- ShardingSphereRuleMetaData globalRuleMetaData = new
ShardingSphereRuleMetaData(Arrays.asList(new SQLTranslatorRule(new
DefaultSQLTranslatorRuleConfigurationBuilder().build()),
- new LoggingRule(new
DefaultLoggingRuleConfigurationBuilder().build())));
-
when(ProxyContext.getInstance().getContextManager().getMetaDataContexts().getMetaData().getGlobalRuleMetaData()).thenReturn(globalRuleMetaData);
- ConnectionSession connectionSession = mock(ConnectionSession.class);
- when(connectionSession.getDatabaseName()).thenReturn("db");
- when(connectionSession.getConnectionContext()).thenReturn(new
ConnectionContext());
-
when(connectionSession.getServerPreparedStatementRegistry()).thenReturn(new
ServerPreparedStatementRegistry());
- ShardingSphereDatabase database = mock(ShardingSphereDatabase.class,
RETURNS_DEEP_STUBS);
-
when(database.getResourceMetaData().getAllInstanceDataSourceNames()).thenReturn(Collections.singletonList("ds_0"));
-
when(database.getResourceMetaData().getStorageTypes()).thenReturn(Collections.singletonMap("ds_0",
new PostgreSQLDatabaseType()));
- when(database.getRuleMetaData()).thenReturn(new
ShardingSphereRuleMetaData(Collections.emptyList()));
-
when(ProxyContext.getInstance().getContextManager().getMetaDataContexts().getMetaData().getDatabase("db")).thenReturn(database);
- SQLStatement sqlStatement = SQL_PARSER_ENGINE.parse(SQL, false);
+ ConnectionSession connectionSession = mockConnectionSession();
+ PostgreSQLAggregatedBatchedStatementsCommandExecutor executor = new
PostgreSQLAggregatedBatchedStatementsCommandExecutor(connectionSession,
createPackets());
+ ContextManager contextManager = mockContextManager();
+ try (MockedStatic<ProxyContext> proxyContext =
mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
+ proxyContext.when(() ->
ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ List<DatabasePacket<?>> actualPackets = new
ArrayList<>(executor.execute());
+ assertThat(actualPackets.size(), is(BATCH_SIZE * 3));
+ for (int i = 0; i < BATCH_SIZE; i++) {
+ assertThat(actualPackets.get(i * 3),
is(PostgreSQLBindCompletePacket.getInstance()));
+ assertThat(actualPackets.get(i * 3 + 1),
is(PostgreSQLNoDataPacket.getInstance()));
+ assertThat(actualPackets.get(i * 3 + 2),
instanceOf(PostgreSQLCommandCompletePacket.class));
+ }
+ }
+ }
+
+ private static ConnectionSession mockConnectionSession() throws
SQLException {
+ ConnectionSession result = mock(ConnectionSession.class);
+ @SuppressWarnings("rawtypes")
SQLStatementContext sqlStatementContext =
mock(InsertStatementContext.class);
- when(sqlStatementContext.getSqlStatement()).thenReturn(sqlStatement);
-
connectionSession.getServerPreparedStatementRegistry().addPreparedStatement(STATEMENT_ID,
+
when(sqlStatementContext.getSqlStatement()).thenReturn(SQL_PARSER_ENGINE.parse(SQL,
false));
+ when(result.getDatabaseName()).thenReturn("db");
+ when(result.getConnectionContext()).thenReturn(new
ConnectionContext());
+ when(result.getServerPreparedStatementRegistry()).thenReturn(new
ServerPreparedStatementRegistry());
+
result.getServerPreparedStatementRegistry().addPreparedStatement(STATEMENT_ID,
new PostgreSQLServerPreparedStatement(SQL,
sqlStatementContext,
Collections.singletonList(PostgreSQLColumnType.POSTGRESQL_TYPE_INT4)));
- when(connectionSession.getConnectionId()).thenReturn(CONNECTION_ID);
+ when(result.getConnectionId()).thenReturn(CONNECTION_ID);
BackendConnection backendConnection = mock(BackendConnection.class);
Connection connection = mock(Connection.class, RETURNS_DEEP_STUBS);
when(connection.getMetaData().getURL()).thenReturn("jdbc:postgresql://127.0.0.1/db");
@@ -122,20 +120,13 @@ public final class
PostgreSQLAggregatedBatchedStatementsCommandExecutorTest exte
JDBCBackendStatement backendStatement =
mock(JDBCBackendStatement.class);
when(backendStatement.createStorageResource(any(ExecutionUnit.class),
any(Connection.class), any(ConnectionMode.class), any(StatementOption.class),
nullable(DatabaseType.class)))
.thenReturn(preparedStatement);
-
when(connectionSession.getStatementManager()).thenReturn(backendStatement);
-
when(connectionSession.getBackendConnection()).thenReturn(backendConnection);
- PostgreSQLAggregatedBatchedStatementsCommandExecutor
batchedStatementsCommandExecutor = new
PostgreSQLAggregatedBatchedStatementsCommandExecutor(connectionSession,
preparePackets());
- List<DatabasePacket<?>> actualPackets = new
ArrayList<>(batchedStatementsCommandExecutor.execute());
- assertThat(actualPackets.size(), is(BATCH_SIZE * 3));
- for (int i = 0; i < BATCH_SIZE; i++) {
- assertThat(actualPackets.get(i * 3),
is(PostgreSQLBindCompletePacket.getInstance()));
- assertThat(actualPackets.get(i * 3 + 1),
is(PostgreSQLNoDataPacket.getInstance()));
- assertThat(actualPackets.get(i * 3 + 2),
instanceOf(PostgreSQLCommandCompletePacket.class));
- }
+ when(result.getStatementManager()).thenReturn(backendStatement);
+ when(result.getBackendConnection()).thenReturn(backendConnection);
+ return result;
}
- private List<PostgreSQLCommandPacket> preparePackets() {
- List<PostgreSQLCommandPacket> result = new ArrayList<>();
+ private List<PostgreSQLCommandPacket> createPackets() {
+ List<PostgreSQLCommandPacket> result = new ArrayList<>(BATCH_SIZE);
for (int i = 0; i < BATCH_SIZE; i++) {
PostgreSQLComBindPacket bindPacket =
mock(PostgreSQLComBindPacket.class);
when(bindPacket.getStatementId()).thenReturn(STATEMENT_ID);
@@ -148,4 +139,20 @@ public final class
PostgreSQLAggregatedBatchedStatementsCommandExecutorTest exte
}
return result;
}
+
+ private static ContextManager mockContextManager() {
+ ContextManager result = mock(ContextManager.class, RETURNS_DEEP_STUBS);
+
when(result.getMetaDataContexts().getMetaData().getProps().<Integer>getValue(ConfigurationPropertyKey.KERNEL_EXECUTOR_SIZE)).thenReturn(0);
+
when(result.getMetaDataContexts().getMetaData().getProps().<Integer>getValue(ConfigurationPropertyKey.MAX_CONNECTIONS_SIZE_PER_QUERY)).thenReturn(1);
+
when(result.getMetaDataContexts().getMetaData().getProps().<Boolean>getValue(ConfigurationPropertyKey.SQL_SHOW)).thenReturn(false);
+ ShardingSphereRuleMetaData globalRuleMetaData = new
ShardingSphereRuleMetaData(Arrays.asList(new SQLTranslatorRule(new
DefaultSQLTranslatorRuleConfigurationBuilder().build()),
+ new LoggingRule(new
DefaultLoggingRuleConfigurationBuilder().build())));
+
when(result.getMetaDataContexts().getMetaData().getGlobalRuleMetaData()).thenReturn(globalRuleMetaData);
+ ShardingSphereDatabase database = mock(ShardingSphereDatabase.class,
RETURNS_DEEP_STUBS);
+
when(database.getResourceMetaData().getAllInstanceDataSourceNames()).thenReturn(Collections.singletonList("ds_0"));
+
when(database.getResourceMetaData().getStorageTypes()).thenReturn(Collections.singletonMap("ds_0",
new PostgreSQLDatabaseType()));
+ when(database.getRuleMetaData()).thenReturn(new
ShardingSphereRuleMetaData(Collections.emptyList()));
+
when(result.getMetaDataContexts().getMetaData().getDatabase("db")).thenReturn(database);
+ return result;
+ }
}
diff --git
a/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/query/extended/PostgreSQLBatchedStatementsExecutorTest.java
b/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/query/extended/PostgreSQLBatchedStatementsExecutorTest.java
index a6fa60f1c2b..cff1a6f872e 100644
---
a/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/query/extended/PostgreSQLBatchedStatementsExecutorTest.java
+++
b/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/query/extended/PostgreSQLBatchedStatementsExecutorTest.java
@@ -37,16 +37,15 @@ import
org.apache.shardingsphere.proxy.backend.connector.BackendConnection;
import
org.apache.shardingsphere.proxy.backend.connector.jdbc.statement.JDBCBackendStatement;
import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
import org.apache.shardingsphere.proxy.backend.session.ConnectionSession;
-import
org.apache.shardingsphere.proxy.frontend.postgresql.ProxyContextRestorer;
import
org.apache.shardingsphere.sql.parser.sql.dialect.statement.postgresql.dml.PostgreSQLInsertStatement;
import org.apache.shardingsphere.sqltranslator.rule.SQLTranslatorRule;
import
org.apache.shardingsphere.sqltranslator.rule.builder.DefaultSQLTranslatorRuleConfigurationBuilder;
-import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
-import org.mockito.Answers;
import org.mockito.InOrder;
import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
import org.mockito.internal.configuration.plugins.Plugins;
import org.mockito.junit.MockitoJUnitRunner;
@@ -67,13 +66,11 @@ import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
-public final class PostgreSQLBatchedStatementsExecutorTest extends
ProxyContextRestorer {
-
- @Mock
- private ConnectionSession connectionSession;
+public final class PostgreSQLBatchedStatementsExecutorTest {
@Mock
private BackendConnection backendConnection;
@@ -81,39 +78,8 @@ public final class PostgreSQLBatchedStatementsExecutorTest
extends ProxyContextR
@Mock
private JDBCBackendStatement backendStatement;
- @Mock(answer = Answers.RETURNS_DEEP_STUBS)
- private ContextManager contextManager;
-
- @Before
- public void setup() {
- when(connectionSession.getDatabaseName()).thenReturn("db");
-
when(connectionSession.getBackendConnection()).thenReturn(backendConnection);
-
when(connectionSession.getStatementManager()).thenReturn(backendStatement);
- when(connectionSession.getConnectionContext()).thenReturn(new
ConnectionContext());
- ProxyContext.init(contextManager);
-
when(contextManager.getMetaDataContexts().getMetaData().getProps().getValue(ConfigurationPropertyKey.KERNEL_EXECUTOR_SIZE)).thenReturn(1);
-
when(contextManager.getMetaDataContexts().getMetaData().getProps().getValue(ConfigurationPropertyKey.MAX_CONNECTIONS_SIZE_PER_QUERY)).thenReturn(1);
-
when(contextManager.getMetaDataContexts().getMetaData().getProps().getValue(ConfigurationPropertyKey.SQL_SHOW)).thenReturn(false);
- ShardingSphereDatabase database = mock(ShardingSphereDatabase.class,
RETURNS_DEEP_STUBS);
-
when(database.getResourceMetaData().getStorageTypes()).thenReturn(Collections.singletonMap("ds_0",
new PostgreSQLDatabaseType()));
-
when(database.getResourceMetaData().getAllInstanceDataSourceNames()).thenReturn(Collections.singletonList("ds_0"));
- when(database.getRuleMetaData()).thenReturn(new
ShardingSphereRuleMetaData(Collections.emptyList()));
-
when(contextManager.getMetaDataContexts().getMetaData().getDatabase("db")).thenReturn(database);
- ShardingSphereRuleMetaData globalRuleMetaData = new
ShardingSphereRuleMetaData(Arrays.asList(new SQLTranslatorRule(new
DefaultSQLTranslatorRuleConfigurationBuilder().build()),
- new LoggingRule(new
DefaultLoggingRuleConfigurationBuilder().build())));
-
when(ProxyContext.getInstance().getContextManager().getMetaDataContexts().getMetaData().getGlobalRuleMetaData()).thenReturn(globalRuleMetaData);
- }
-
@Test
public void assertExecuteBatch() throws SQLException {
- PostgreSQLInsertStatement insertStatement =
mock(PostgreSQLInsertStatement.class, RETURNS_DEEP_STUBS);
-
when(insertStatement.getTable().getTableName().getIdentifier().getValue()).thenReturn("t");
- InsertStatementContext insertStatementContext =
mock(InsertStatementContext.class);
-
when(insertStatementContext.getSqlStatement()).thenReturn(insertStatement);
- PostgreSQLServerPreparedStatement postgreSQLPreparedStatement = new
PostgreSQLServerPreparedStatement("insert into t (id, col) values (?, ?)",
insertStatementContext,
- Arrays.asList(PostgreSQLColumnType.POSTGRESQL_TYPE_INT4,
PostgreSQLColumnType.POSTGRESQL_TYPE_VARCHAR));
- List<List<Object>> parameterSets = Arrays.asList(Arrays.asList(1, new
PostgreSQLTypeUnspecifiedSQLParameter("foo")),
- Arrays.asList(2, new
PostgreSQLTypeUnspecifiedSQLParameter("bar")), Arrays.asList(3, new
PostgreSQLTypeUnspecifiedSQLParameter("baz")));
Connection connection = mock(Connection.class, RETURNS_DEEP_STUBS);
when(connection.getMetaData().getURL()).thenReturn("jdbc:postgresql://127.0.0.1/db");
when(backendConnection.getConnections(nullable(String.class),
anyInt(),
any(ConnectionMode.class))).thenReturn(Collections.singletonList(connection));
@@ -122,18 +88,60 @@ public final class PostgreSQLBatchedStatementsExecutorTest
extends ProxyContextR
when(preparedStatement.executeBatch()).thenReturn(new int[]{1, 1, 1});
when(backendStatement.createStorageResource(any(ExecutionUnit.class),
eq(connection), any(ConnectionMode.class), any(StatementOption.class),
nullable(DatabaseType.class)))
.thenReturn(preparedStatement);
- PostgreSQLBatchedStatementsExecutor actual = new
PostgreSQLBatchedStatementsExecutor(connectionSession,
postgreSQLPreparedStatement, parameterSets);
- prepareExecutionUnitParameters(actual, parameterSets);
- int actualUpdated = actual.executeBatch();
- assertThat(actualUpdated, is(3));
- InOrder inOrder = inOrder(preparedStatement);
- for (List<Object> each : parameterSets) {
- inOrder.verify(preparedStatement).setObject(1, each.get(0));
- inOrder.verify(preparedStatement).setObject(2,
each.get(1).toString());
- inOrder.verify(preparedStatement).addBatch();
+ ContextManager contextManager = mockContextManager();
+ ConnectionSession connectionSession = mockConnectionSession();
+ PostgreSQLServerPreparedStatement postgreSQLPreparedStatement = new
PostgreSQLServerPreparedStatement("insert into t (id, col) values (?, ?)",
mockInsertStatementContext(),
+ Arrays.asList(PostgreSQLColumnType.POSTGRESQL_TYPE_INT4,
PostgreSQLColumnType.POSTGRESQL_TYPE_VARCHAR));
+ List<List<Object>> parameterSets = Arrays.asList(Arrays.asList(1, new
PostgreSQLTypeUnspecifiedSQLParameter("foo")),
+ Arrays.asList(2, new
PostgreSQLTypeUnspecifiedSQLParameter("bar")), Arrays.asList(3, new
PostgreSQLTypeUnspecifiedSQLParameter("baz")));
+ try (MockedStatic<ProxyContext> proxyContext =
mockStatic(ProxyContext.class, Mockito.RETURNS_DEEP_STUBS)) {
+ proxyContext.when(() ->
ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ PostgreSQLBatchedStatementsExecutor actual = new
PostgreSQLBatchedStatementsExecutor(connectionSession,
postgreSQLPreparedStatement, parameterSets);
+ prepareExecutionUnitParameters(actual, parameterSets);
+ int actualUpdated = actual.executeBatch();
+ assertThat(actualUpdated, is(3));
+ InOrder inOrder = inOrder(preparedStatement);
+ for (List<Object> each : parameterSets) {
+ inOrder.verify(preparedStatement).setObject(1, each.get(0));
+ inOrder.verify(preparedStatement).setObject(2,
each.get(1).toString());
+ inOrder.verify(preparedStatement).addBatch();
+ }
}
}
+ private static InsertStatementContext mockInsertStatementContext() {
+ PostgreSQLInsertStatement insertStatement =
mock(PostgreSQLInsertStatement.class, RETURNS_DEEP_STUBS);
+
when(insertStatement.getTable().getTableName().getIdentifier().getValue()).thenReturn("t");
+ InsertStatementContext result = mock(InsertStatementContext.class);
+ when(result.getSqlStatement()).thenReturn(insertStatement);
+ return result;
+ }
+
+ private ContextManager mockContextManager() {
+ ContextManager result = mock(ContextManager.class, RETURNS_DEEP_STUBS);
+
when(result.getMetaDataContexts().getMetaData().getProps().getValue(ConfigurationPropertyKey.KERNEL_EXECUTOR_SIZE)).thenReturn(1);
+
when(result.getMetaDataContexts().getMetaData().getProps().getValue(ConfigurationPropertyKey.MAX_CONNECTIONS_SIZE_PER_QUERY)).thenReturn(1);
+
when(result.getMetaDataContexts().getMetaData().getProps().getValue(ConfigurationPropertyKey.SQL_SHOW)).thenReturn(false);
+ ShardingSphereDatabase database = mock(ShardingSphereDatabase.class,
RETURNS_DEEP_STUBS);
+
when(database.getResourceMetaData().getStorageTypes()).thenReturn(Collections.singletonMap("ds_0",
new PostgreSQLDatabaseType()));
+
when(database.getResourceMetaData().getAllInstanceDataSourceNames()).thenReturn(Collections.singletonList("ds_0"));
+ when(database.getRuleMetaData()).thenReturn(new
ShardingSphereRuleMetaData(Collections.emptyList()));
+
when(result.getMetaDataContexts().getMetaData().getDatabase("db")).thenReturn(database);
+ ShardingSphereRuleMetaData globalRuleMetaData = new
ShardingSphereRuleMetaData(Arrays.asList(new SQLTranslatorRule(new
DefaultSQLTranslatorRuleConfigurationBuilder().build()),
+ new LoggingRule(new
DefaultLoggingRuleConfigurationBuilder().build())));
+
when(result.getMetaDataContexts().getMetaData().getGlobalRuleMetaData()).thenReturn(globalRuleMetaData);
+ return result;
+ }
+
+ private ConnectionSession mockConnectionSession() {
+ ConnectionSession result = mock(ConnectionSession.class);
+ when(result.getDatabaseName()).thenReturn("db");
+ when(result.getBackendConnection()).thenReturn(backendConnection);
+ when(result.getStatementManager()).thenReturn(backendStatement);
+ when(result.getConnectionContext()).thenReturn(new
ConnectionContext());
+ return result;
+ }
+
@SuppressWarnings("unchecked")
@SneakyThrows(ReflectiveOperationException.class)
private void prepareExecutionUnitParameters(final
PostgreSQLBatchedStatementsExecutor target, final List<List<Object>>
parameterSets) {
diff --git
a/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/query/extended/bind/PostgreSQLComBindExecutorTest.java
b/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/query/extended/bind/PostgreSQLComBindExecutorTest.java
index 9f0372fb20a..16792e07309 100644
---
a/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/query/extended/bind/PostgreSQLComBindExecutorTest.java
+++
b/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/query/extended/bind/PostgreSQLComBindExecutorTest.java
@@ -29,7 +29,6 @@ import
org.apache.shardingsphere.proxy.backend.context.ProxyContext;
import org.apache.shardingsphere.proxy.backend.session.ConnectionSession;
import
org.apache.shardingsphere.proxy.backend.session.ServerPreparedStatementRegistry;
import
org.apache.shardingsphere.proxy.backend.session.transaction.TransactionStatus;
-import
org.apache.shardingsphere.proxy.frontend.postgresql.ProxyContextRestorer;
import
org.apache.shardingsphere.proxy.frontend.postgresql.command.PortalContext;
import
org.apache.shardingsphere.proxy.frontend.postgresql.command.query.extended.Portal;
import
org.apache.shardingsphere.proxy.frontend.postgresql.command.query.extended.PostgreSQLServerPreparedStatement;
@@ -37,8 +36,11 @@ import
org.apache.shardingsphere.sql.parser.sql.dialect.statement.postgresql.dal
import org.apache.shardingsphere.transaction.api.TransactionType;
import org.junit.Test;
import org.junit.runner.RunWith;
+import org.mockito.Answers;
import org.mockito.InjectMocks;
import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import java.sql.SQLException;
@@ -49,13 +51,13 @@ import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyList;
-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.verify;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
-public final class PostgreSQLComBindExecutorTest extends ProxyContextRestorer {
+public final class PostgreSQLComBindExecutorTest {
@Mock
private PortalContext portalContext;
@@ -71,11 +73,8 @@ public final class PostgreSQLComBindExecutorTest extends
ProxyContextRestorer {
@Test
public void assertExecuteBind() throws SQLException {
- ProxyContext.init(mock(ContextManager.class, RETURNS_DEEP_STUBS));
String databaseName = "postgres";
-
when(ProxyContext.getInstance().getContextManager().getMetaDataContexts().getMetaData().containsDatabase(databaseName)).thenReturn(true);
ShardingSphereDatabase database = mock(ShardingSphereDatabase.class);
-
when(ProxyContext.getInstance().getDatabase(databaseName)).thenReturn(database);
when(database.getProtocolType()).thenReturn(new
PostgreSQLDatabaseType());
when(connectionSession.getServerPreparedStatementRegistry()).thenReturn(new
ServerPreparedStatementRegistry());
BackendConnection backendConnection = mock(BackendConnection.class);
@@ -90,9 +89,20 @@ public final class PostgreSQLComBindExecutorTest extends
ProxyContextRestorer {
when(bindPacket.getPortal()).thenReturn("C_1");
when(bindPacket.readParameters(anyList())).thenReturn(Collections.emptyList());
when(bindPacket.readResultFormats()).thenReturn(Collections.emptyList());
- Collection<DatabasePacket<?>> actual = executor.execute();
- assertThat(actual.size(), is(1));
- assertThat(actual.iterator().next(),
is(PostgreSQLBindCompletePacket.getInstance()));
- verify(portalContext).add(any(Portal.class));
+ ContextManager contextManager = mockContextManager(databaseName);
+ try (MockedStatic<ProxyContext> proxyContext =
mockStatic(ProxyContext.class, Mockito.RETURNS_DEEP_STUBS)) {
+ proxyContext.when(() ->
ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ proxyContext.when(() ->
ProxyContext.getInstance().getDatabase(databaseName)).thenReturn(database);
+ Collection<DatabasePacket<?>> actual = executor.execute();
+ assertThat(actual.size(), is(1));
+ assertThat(actual.iterator().next(),
is(PostgreSQLBindCompletePacket.getInstance()));
+ verify(portalContext).add(any(Portal.class));
+ }
+ }
+
+ private ContextManager mockContextManager(final String databaseName) {
+ ContextManager result = mock(ContextManager.class,
Answers.RETURNS_DEEP_STUBS);
+
when(result.getMetaDataContexts().getMetaData().containsDatabase(databaseName)).thenReturn(true);
+ return result;
}
}
diff --git
a/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/query/extended/describe/PostgreSQLComDescribeExecutorTest.java
b/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/query/extended/describe/PostgreSQLComDescribeExecutorTest.java
index 9a20c3a9b96..349cc395663 100644
---
a/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/query/extended/describe/PostgreSQLComDescribeExecutorTest.java
+++
b/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/query/extended/describe/PostgreSQLComDescribeExecutorTest.java
@@ -46,7 +46,6 @@ 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.ServerPreparedStatementRegistry;
-import
org.apache.shardingsphere.proxy.frontend.postgresql.ProxyContextRestorer;
import
org.apache.shardingsphere.proxy.frontend.postgresql.command.PortalContext;
import
org.apache.shardingsphere.proxy.frontend.postgresql.command.query.extended.Portal;
import
org.apache.shardingsphere.proxy.frontend.postgresql.command.query.extended.PostgreSQLServerPreparedStatement;
@@ -54,12 +53,11 @@ import org.apache.shardingsphere.sql.parser.api.CacheOption;
import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
import org.apache.shardingsphere.sqltranslator.rule.SQLTranslatorRule;
import
org.apache.shardingsphere.sqltranslator.rule.builder.DefaultSQLTranslatorRuleConfigurationBuilder;
-import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
-import org.mockito.Answers;
import org.mockito.InjectMocks;
import org.mockito.Mock;
+import org.mockito.MockedStatic;
import org.mockito.internal.configuration.plugins.Plugins;
import org.mockito.junit.MockitoJUnitRunner;
@@ -83,12 +81,13 @@ import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.nullable;
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)
-public final class PostgreSQLComDescribeExecutorTest extends
ProxyContextRestorer {
+public final class PostgreSQLComDescribeExecutorTest {
private static final String DATABASE_NAME = "postgres";
@@ -96,9 +95,6 @@ public final class PostgreSQLComDescribeExecutorTest extends
ProxyContextRestore
private static final ShardingSphereSQLParserEngine SQL_PARSER_ENGINE = new
ShardingSphereSQLParserEngine("PostgreSQL", new CacheOption(2000, 65535L), new
CacheOption(128, 1024L), false);
- @Mock(answer = Answers.RETURNS_DEEP_STUBS)
- private ContextManager contextManager;
-
@Mock
private PortalContext portalContext;
@@ -111,33 +107,6 @@ public final class PostgreSQLComDescribeExecutorTest
extends ProxyContextRestore
@InjectMocks
private PostgreSQLComDescribeExecutor executor;
- @Before
- public void setup() {
- ProxyContext.init(contextManager);
-
when(ProxyContext.getInstance().getContextManager().getMetaDataContexts().getMetaData().getProps().getValue(ConfigurationPropertyKey.SQL_SHOW)).thenReturn(false);
- when(connectionSession.getDatabaseName()).thenReturn(DATABASE_NAME);
-
when(connectionSession.getServerPreparedStatementRegistry()).thenReturn(new
ServerPreparedStatementRegistry());
- ShardingSphereRuleMetaData globalRuleMetaData = new
ShardingSphereRuleMetaData(Arrays.asList(new SQLTranslatorRule(new
DefaultSQLTranslatorRuleConfigurationBuilder().build()),
- new LoggingRule(new
DefaultLoggingRuleConfigurationBuilder().build())));
-
when(ProxyContext.getInstance().getContextManager().getMetaDataContexts().getMetaData().getGlobalRuleMetaData()).thenReturn(globalRuleMetaData);
-
when(contextManager.getMetaDataContexts().getMetaData().getDatabases()).thenReturn(Collections.singletonMap(DATABASE_NAME,
mock(ShardingSphereDatabase.class, RETURNS_DEEP_STUBS)));
- prepareTableMetaData();
- }
-
- private void prepareTableMetaData() {
- Collection<ShardingSphereColumn> columnMetaData = Arrays.asList(
- new ShardingSphereColumn("id", Types.INTEGER, true, false,
false, true, false),
- new ShardingSphereColumn("k", Types.INTEGER, true, false,
false, true, false),
- new ShardingSphereColumn("c", Types.CHAR, true, false, false,
true, false),
- new ShardingSphereColumn("pad", Types.CHAR, true, false,
false, true, false));
- ShardingSphereTable table = new ShardingSphereTable(TABLE_NAME,
columnMetaData, Collections.emptyList(), Collections.emptyList());
-
when(contextManager.getMetaDataContexts().getMetaData().getDatabase(DATABASE_NAME).getSchema("public").getTable(TABLE_NAME)).thenReturn(table);
-
when(contextManager.getMetaDataContexts().getMetaData().getDatabase(DATABASE_NAME).getProtocolType()).thenReturn(new
PostgreSQLDatabaseType());
-
when(contextManager.getMetaDataContexts().getMetaData().getDatabase(DATABASE_NAME).getResourceMetaData().getStorageTypes())
- .thenReturn(Collections.singletonMap("ds_0", new
PostgreSQLDatabaseType()));
-
when(contextManager.getMetaDataContexts().getMetaData().containsDatabase(DATABASE_NAME)).thenReturn(true);
- }
-
@Test
public void assertDescribePortal() throws SQLException {
when(packet.getType()).thenReturn('P');
@@ -165,17 +134,23 @@ public final class PostgreSQLComDescribeExecutorTest
extends ProxyContextRestore
}
SQLStatementContext sqlStatementContext =
mock(InsertStatementContext.class);
when(sqlStatementContext.getSqlStatement()).thenReturn(sqlStatement);
-
connectionSession.getServerPreparedStatementRegistry().addPreparedStatement(statementId,
new PostgreSQLServerPreparedStatement(sql, sqlStatementContext,
parameterTypes));
- Collection<DatabasePacket<?>> actualPackets = executor.execute();
- assertThat(actualPackets.size(), is(2));
- Iterator<DatabasePacket<?>> actualPacketsIterator =
actualPackets.iterator();
- PostgreSQLParameterDescriptionPacket actualParameterDescription =
(PostgreSQLParameterDescriptionPacket) actualPacketsIterator.next();
- PostgreSQLPacketPayload mockPayload =
mock(PostgreSQLPacketPayload.class);
- actualParameterDescription.write(mockPayload);
- verify(mockPayload).writeInt2(4);
- verify(mockPayload, times(2)).writeInt4(23);
- verify(mockPayload, times(2)).writeInt4(18);
- assertThat(actualPacketsIterator.next(),
is(PostgreSQLNoDataPacket.getInstance()));
+ ContextManager contextManager = mockContextManager();
+ try (MockedStatic<ProxyContext> proxyContext =
mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
+ proxyContext.when(() ->
ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ ShardingSphereDatabase database =
contextManager.getMetaDataContexts().getMetaData().getDatabase(DATABASE_NAME);
+ proxyContext.when(() ->
ProxyContext.getInstance().getDatabase(DATABASE_NAME)).thenReturn(database);
+
connectionSession.getServerPreparedStatementRegistry().addPreparedStatement(statementId,
new PostgreSQLServerPreparedStatement(sql, sqlStatementContext,
parameterTypes));
+ Collection<DatabasePacket<?>> actualPackets = executor.execute();
+ assertThat(actualPackets.size(), is(2));
+ Iterator<DatabasePacket<?>> actualPacketsIterator =
actualPackets.iterator();
+ PostgreSQLParameterDescriptionPacket actualParameterDescription =
(PostgreSQLParameterDescriptionPacket) actualPacketsIterator.next();
+ PostgreSQLPacketPayload mockPayload =
mock(PostgreSQLPacketPayload.class);
+ actualParameterDescription.write(mockPayload);
+ verify(mockPayload).writeInt2(4);
+ verify(mockPayload, times(2)).writeInt4(23);
+ verify(mockPayload, times(2)).writeInt4(18);
+ assertThat(actualPacketsIterator.next(),
is(PostgreSQLNoDataPacket.getInstance()));
+ }
}
@SuppressWarnings("rawtypes")
@@ -192,17 +167,23 @@ public final class PostgreSQLComDescribeExecutorTest
extends ProxyContextRestore
}
SQLStatementContext sqlStatementContext =
mock(InsertStatementContext.class);
when(sqlStatementContext.getSqlStatement()).thenReturn(sqlStatement);
-
connectionSession.getServerPreparedStatementRegistry().addPreparedStatement(statementId,
new PostgreSQLServerPreparedStatement(sql, sqlStatementContext,
parameterTypes));
- Collection<DatabasePacket<?>> actualPackets = executor.execute();
- assertThat(actualPackets.size(), is(2));
- Iterator<DatabasePacket<?>> actualPacketsIterator =
actualPackets.iterator();
- PostgreSQLParameterDescriptionPacket actualParameterDescription =
(PostgreSQLParameterDescriptionPacket) actualPacketsIterator.next();
- PostgreSQLPacketPayload mockPayload =
mock(PostgreSQLPacketPayload.class);
- actualParameterDescription.write(mockPayload);
- verify(mockPayload).writeInt2(5);
- verify(mockPayload, times(2)).writeInt4(23);
- verify(mockPayload, times(3)).writeInt4(18);
- assertThat(actualPacketsIterator.next(),
is(PostgreSQLNoDataPacket.getInstance()));
+ ContextManager contextManager = mockContextManager();
+ try (MockedStatic<ProxyContext> proxyContext =
mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
+ proxyContext.when(() ->
ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ ShardingSphereDatabase database =
contextManager.getMetaDataContexts().getMetaData().getDatabase(DATABASE_NAME);
+ proxyContext.when(() ->
ProxyContext.getInstance().getDatabase(DATABASE_NAME)).thenReturn(database);
+
connectionSession.getServerPreparedStatementRegistry().addPreparedStatement(statementId,
new PostgreSQLServerPreparedStatement(sql, sqlStatementContext,
parameterTypes));
+ Collection<DatabasePacket<?>> actualPackets = executor.execute();
+ assertThat(actualPackets.size(), is(2));
+ Iterator<DatabasePacket<?>> actualPacketsIterator =
actualPackets.iterator();
+ PostgreSQLParameterDescriptionPacket actualParameterDescription =
(PostgreSQLParameterDescriptionPacket) actualPacketsIterator.next();
+ PostgreSQLPacketPayload mockPayload =
mock(PostgreSQLPacketPayload.class);
+ actualParameterDescription.write(mockPayload);
+ verify(mockPayload).writeInt2(5);
+ verify(mockPayload, times(2)).writeInt4(23);
+ verify(mockPayload, times(3)).writeInt4(18);
+ assertThat(actualPacketsIterator.next(),
is(PostgreSQLNoDataPacket.getInstance()));
+ }
}
@SuppressWarnings("rawtypes")
@@ -219,17 +200,23 @@ public final class PostgreSQLComDescribeExecutorTest
extends ProxyContextRestore
}
SQLStatementContext sqlStatementContext =
mock(InsertStatementContext.class);
when(sqlStatementContext.getSqlStatement()).thenReturn(sqlStatement);
-
connectionSession.getServerPreparedStatementRegistry().addPreparedStatement(statementId,
new PostgreSQLServerPreparedStatement(sql, sqlStatementContext,
parameterTypes));
- Collection<DatabasePacket<?>> actualPackets = executor.execute();
- assertThat(actualPackets.size(), is(2));
- Iterator<DatabasePacket<?>> actualPacketsIterator =
actualPackets.iterator();
- PostgreSQLParameterDescriptionPacket actualParameterDescription =
(PostgreSQLParameterDescriptionPacket) actualPacketsIterator.next();
- PostgreSQLPacketPayload mockPayload =
mock(PostgreSQLPacketPayload.class);
- actualParameterDescription.write(mockPayload);
- verify(mockPayload).writeInt2(5);
- verify(mockPayload, times(2)).writeInt4(23);
- verify(mockPayload, times(3)).writeInt4(18);
- assertThat(actualPacketsIterator.next(),
is(PostgreSQLNoDataPacket.getInstance()));
+ ContextManager contextManager = mockContextManager();
+ try (MockedStatic<ProxyContext> proxyContext =
mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
+ proxyContext.when(() ->
ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ ShardingSphereDatabase database =
contextManager.getMetaDataContexts().getMetaData().getDatabase(DATABASE_NAME);
+ proxyContext.when(() ->
ProxyContext.getInstance().getDatabase(DATABASE_NAME)).thenReturn(database);
+
connectionSession.getServerPreparedStatementRegistry().addPreparedStatement(statementId,
new PostgreSQLServerPreparedStatement(sql, sqlStatementContext,
parameterTypes));
+ Collection<DatabasePacket<?>> actualPackets = executor.execute();
+ assertThat(actualPackets.size(), is(2));
+ Iterator<DatabasePacket<?>> actualPacketsIterator =
actualPackets.iterator();
+ PostgreSQLParameterDescriptionPacket actualParameterDescription =
(PostgreSQLParameterDescriptionPacket) actualPacketsIterator.next();
+ PostgreSQLPacketPayload mockPayload =
mock(PostgreSQLPacketPayload.class);
+ actualParameterDescription.write(mockPayload);
+ verify(mockPayload).writeInt2(5);
+ verify(mockPayload, times(2)).writeInt4(23);
+ verify(mockPayload, times(3)).writeInt4(18);
+ assertThat(actualPacketsIterator.next(),
is(PostgreSQLNoDataPacket.getInstance()));
+ }
}
@SuppressWarnings("rawtypes")
@@ -246,8 +233,14 @@ public final class PostgreSQLComDescribeExecutorTest
extends ProxyContextRestore
}
SQLStatementContext sqlStatementContext =
mock(InsertStatementContext.class);
when(sqlStatementContext.getSqlStatement()).thenReturn(sqlStatement);
-
connectionSession.getServerPreparedStatementRegistry().addPreparedStatement(statementId,
new PostgreSQLServerPreparedStatement(sql, sqlStatementContext,
parameterTypes));
- executor.execute();
+ ContextManager contextManager = mockContextManager();
+ try (MockedStatic<ProxyContext> proxyContext =
mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
+ proxyContext.when(() ->
ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ ShardingSphereDatabase database =
contextManager.getMetaDataContexts().getMetaData().getDatabase(DATABASE_NAME);
+ proxyContext.when(() ->
ProxyContext.getInstance().getDatabase(DATABASE_NAME)).thenReturn(database);
+
connectionSession.getServerPreparedStatementRegistry().addPreparedStatement(statementId,
new PostgreSQLServerPreparedStatement(sql, sqlStatementContext,
parameterTypes));
+ executor.execute();
+ }
}
@SuppressWarnings("rawtypes")
@@ -265,19 +258,25 @@ public final class PostgreSQLComDescribeExecutorTest
extends ProxyContextRestore
}
SQLStatementContext sqlStatementContext =
mock(InsertStatementContext.class);
when(sqlStatementContext.getSqlStatement()).thenReturn(sqlStatement);
-
connectionSession.getServerPreparedStatementRegistry().addPreparedStatement(statementId,
new PostgreSQLServerPreparedStatement(sql, sqlStatementContext,
parameterTypes));
- Collection<DatabasePacket<?>> actualPackets = executor.execute();
- assertThat(actualPackets.size(), is(2));
- Iterator<DatabasePacket<?>> actualPacketsIterator =
actualPackets.iterator();
- PostgreSQLParameterDescriptionPacket actualParameterDescription =
(PostgreSQLParameterDescriptionPacket) actualPacketsIterator.next();
- PostgreSQLPacketPayload mockPayload =
mock(PostgreSQLPacketPayload.class);
- actualParameterDescription.write(mockPayload);
- verify(mockPayload).writeInt2(3);
- verify(mockPayload).writeInt4(23);
- verify(mockPayload, times(2)).writeInt4(18);
- DatabasePacket<?> actualRowDescriptionPacket =
actualPacketsIterator.next();
- assertThat(actualRowDescriptionPacket,
is(instanceOf(PostgreSQLRowDescriptionPacket.class)));
- assertRowDescriptions((PostgreSQLRowDescriptionPacket)
actualRowDescriptionPacket);
+ ContextManager contextManager = mockContextManager();
+ try (MockedStatic<ProxyContext> proxyContext =
mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
+ proxyContext.when(() ->
ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ ShardingSphereDatabase database =
contextManager.getMetaDataContexts().getMetaData().getDatabase(DATABASE_NAME);
+ proxyContext.when(() ->
ProxyContext.getInstance().getDatabase(DATABASE_NAME)).thenReturn(database);
+
connectionSession.getServerPreparedStatementRegistry().addPreparedStatement(statementId,
new PostgreSQLServerPreparedStatement(sql, sqlStatementContext,
parameterTypes));
+ Collection<DatabasePacket<?>> actualPackets = executor.execute();
+ assertThat(actualPackets.size(), is(2));
+ Iterator<DatabasePacket<?>> actualPacketsIterator =
actualPackets.iterator();
+ PostgreSQLParameterDescriptionPacket actualParameterDescription =
(PostgreSQLParameterDescriptionPacket) actualPacketsIterator.next();
+ PostgreSQLPacketPayload mockPayload =
mock(PostgreSQLPacketPayload.class);
+ actualParameterDescription.write(mockPayload);
+ verify(mockPayload).writeInt2(3);
+ verify(mockPayload).writeInt4(23);
+ verify(mockPayload, times(2)).writeInt4(18);
+ DatabasePacket<?> actualRowDescriptionPacket =
actualPacketsIterator.next();
+ assertThat(actualRowDescriptionPacket,
is(instanceOf(PostgreSQLRowDescriptionPacket.class)));
+ assertRowDescriptions((PostgreSQLRowDescriptionPacket)
actualRowDescriptionPacket);
+ }
}
private void assertRowDescriptions(final PostgreSQLRowDescriptionPacket
actualRowDescriptionPacket) {
@@ -342,33 +341,61 @@ public final class PostgreSQLComDescribeExecutorTest
extends ProxyContextRestore
when(sqlStatementContext.getSqlStatement()).thenReturn(sqlStatement);
prepareJDBCBackendConnection(sql);
List<PostgreSQLColumnType> parameterTypes = new
ArrayList<>(Collections.singleton(PostgreSQLColumnType.POSTGRESQL_TYPE_UNSPECIFIED));
-
connectionSession.getServerPreparedStatementRegistry().addPreparedStatement(statementId,
new PostgreSQLServerPreparedStatement(sql, sqlStatementContext,
parameterTypes));
- Collection<DatabasePacket<?>> actual = executor.execute();
- assertThat(actual.size(), is(2));
- Iterator<DatabasePacket<?>> actualPacketsIterator = actual.iterator();
- PostgreSQLParameterDescriptionPacket actualParameterDescription =
(PostgreSQLParameterDescriptionPacket) actualPacketsIterator.next();
- assertThat(actualParameterDescription,
instanceOf(PostgreSQLParameterDescriptionPacket.class));
- PostgreSQLPacketPayload mockPayload =
mock(PostgreSQLPacketPayload.class);
- actualParameterDescription.write(mockPayload);
- verify(mockPayload).writeInt2(1);
-
verify(mockPayload).writeInt4(PostgreSQLColumnType.POSTGRESQL_TYPE_INT4.getValue());
- PostgreSQLRowDescriptionPacket actualRowDescription =
(PostgreSQLRowDescriptionPacket) actualPacketsIterator.next();
- List<PostgreSQLColumnDescription> actualColumnDescriptions =
getColumnDescriptions(actualRowDescription);
- List<PostgreSQLColumnDescription> expectedColumnDescriptions =
Arrays.asList(
- new PostgreSQLColumnDescription("id", 1, Types.INTEGER, 11,
"int4"),
- new PostgreSQLColumnDescription("k", 2, Types.INTEGER, 11,
"int4"),
- new PostgreSQLColumnDescription("c", 3, Types.CHAR, 60,
"int4"),
- new PostgreSQLColumnDescription("pad", 4, Types.CHAR, 120,
"int4"));
- for (int i = 0; i < expectedColumnDescriptions.size(); i++) {
- PostgreSQLColumnDescription expectedColumnDescription =
expectedColumnDescriptions.get(i);
- PostgreSQLColumnDescription actualColumnDescription =
actualColumnDescriptions.get(i);
- assertThat(actualColumnDescription.getColumnName(),
is(expectedColumnDescription.getColumnName()));
- assertThat(actualColumnDescription.getColumnIndex(),
is(expectedColumnDescription.getColumnIndex()));
- assertThat(actualColumnDescription.getColumnLength(),
is(expectedColumnDescription.getColumnLength()));
- assertThat(actualColumnDescription.getTypeOID(),
is(expectedColumnDescription.getTypeOID()));
+ ContextManager contextManager = mockContextManager();
+ try (MockedStatic<ProxyContext> proxyContext =
mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
+ proxyContext.when(() ->
ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ ShardingSphereDatabase database =
contextManager.getMetaDataContexts().getMetaData().getDatabase(DATABASE_NAME);
+ proxyContext.when(() ->
ProxyContext.getInstance().getDatabase(DATABASE_NAME)).thenReturn(database);
+
connectionSession.getServerPreparedStatementRegistry().addPreparedStatement(statementId,
new PostgreSQLServerPreparedStatement(sql, sqlStatementContext,
parameterTypes));
+ Collection<DatabasePacket<?>> actual = executor.execute();
+ assertThat(actual.size(), is(2));
+ Iterator<DatabasePacket<?>> actualPacketsIterator =
actual.iterator();
+ PostgreSQLParameterDescriptionPacket actualParameterDescription =
(PostgreSQLParameterDescriptionPacket) actualPacketsIterator.next();
+ assertThat(actualParameterDescription,
instanceOf(PostgreSQLParameterDescriptionPacket.class));
+ PostgreSQLPacketPayload mockPayload =
mock(PostgreSQLPacketPayload.class);
+ actualParameterDescription.write(mockPayload);
+ verify(mockPayload).writeInt2(1);
+
verify(mockPayload).writeInt4(PostgreSQLColumnType.POSTGRESQL_TYPE_INT4.getValue());
+ PostgreSQLRowDescriptionPacket actualRowDescription =
(PostgreSQLRowDescriptionPacket) actualPacketsIterator.next();
+ List<PostgreSQLColumnDescription> actualColumnDescriptions =
getColumnDescriptions(actualRowDescription);
+ List<PostgreSQLColumnDescription> expectedColumnDescriptions =
Arrays.asList(
+ new PostgreSQLColumnDescription("id", 1, Types.INTEGER,
11, "int4"),
+ new PostgreSQLColumnDescription("k", 2, Types.INTEGER, 11,
"int4"),
+ new PostgreSQLColumnDescription("c", 3, Types.CHAR, 60,
"int4"),
+ new PostgreSQLColumnDescription("pad", 4, Types.CHAR, 120,
"int4"));
+ for (int i = 0; i < expectedColumnDescriptions.size(); i++) {
+ PostgreSQLColumnDescription expectedColumnDescription =
expectedColumnDescriptions.get(i);
+ PostgreSQLColumnDescription actualColumnDescription =
actualColumnDescriptions.get(i);
+ assertThat(actualColumnDescription.getColumnName(),
is(expectedColumnDescription.getColumnName()));
+ assertThat(actualColumnDescription.getColumnIndex(),
is(expectedColumnDescription.getColumnIndex()));
+ assertThat(actualColumnDescription.getColumnLength(),
is(expectedColumnDescription.getColumnLength()));
+ assertThat(actualColumnDescription.getTypeOID(),
is(expectedColumnDescription.getTypeOID()));
+ }
}
}
+ private ContextManager mockContextManager() {
+ ContextManager result = mock(ContextManager.class, RETURNS_DEEP_STUBS);
+
when(result.getMetaDataContexts().getMetaData().getProps().getValue(ConfigurationPropertyKey.SQL_SHOW)).thenReturn(false);
+ when(connectionSession.getDatabaseName()).thenReturn(DATABASE_NAME);
+
when(connectionSession.getServerPreparedStatementRegistry()).thenReturn(new
ServerPreparedStatementRegistry());
+ ShardingSphereRuleMetaData globalRuleMetaData = new
ShardingSphereRuleMetaData(Arrays.asList(new SQLTranslatorRule(new
DefaultSQLTranslatorRuleConfigurationBuilder().build()),
+ new LoggingRule(new
DefaultLoggingRuleConfigurationBuilder().build())));
+
when(result.getMetaDataContexts().getMetaData().getGlobalRuleMetaData()).thenReturn(globalRuleMetaData);
+
when(result.getMetaDataContexts().getMetaData().getDatabases()).thenReturn(Collections.singletonMap(DATABASE_NAME,
mock(ShardingSphereDatabase.class, RETURNS_DEEP_STUBS)));
+ Collection<ShardingSphereColumn> columnMetaData = Arrays.asList(
+ new ShardingSphereColumn("id", Types.INTEGER, true, false,
false, true, false),
+ new ShardingSphereColumn("k", Types.INTEGER, true, false,
false, true, false),
+ new ShardingSphereColumn("c", Types.CHAR, true, false, false,
true, false),
+ new ShardingSphereColumn("pad", Types.CHAR, true, false,
false, true, false));
+ ShardingSphereTable table = new ShardingSphereTable(TABLE_NAME,
columnMetaData, Collections.emptyList(), Collections.emptyList());
+
when(result.getMetaDataContexts().getMetaData().getDatabase(DATABASE_NAME).getSchema("public").getTable(TABLE_NAME)).thenReturn(table);
+
when(result.getMetaDataContexts().getMetaData().getDatabase(DATABASE_NAME).getProtocolType()).thenReturn(new
PostgreSQLDatabaseType());
+
when(result.getMetaDataContexts().getMetaData().getDatabase(DATABASE_NAME).getResourceMetaData().getStorageTypes())
+ .thenReturn(Collections.singletonMap("ds_0", new
PostgreSQLDatabaseType()));
+ return result;
+ }
+
private void prepareJDBCBackendConnection(final String sql) throws
SQLException {
BackendConnection backendConnection = mock(BackendConnection.class);
Connection connection = mock(Connection.class, RETURNS_DEEP_STUBS);
diff --git
a/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/query/extended/parse/PostgreSQLComParseExecutorTest.java
b/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/query/extended/parse/PostgreSQLComParseExecutorTest.java
index 42f6858b6cc..33d421af973 100644
---
a/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/query/extended/parse/PostgreSQLComParseExecutorTest.java
+++
b/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/query/extended/parse/PostgreSQLComParseExecutorTest.java
@@ -34,16 +34,15 @@ import
org.apache.shardingsphere.proxy.backend.context.ProxyContext;
import org.apache.shardingsphere.proxy.backend.distsql.DistSQLStatementContext;
import org.apache.shardingsphere.proxy.backend.session.ConnectionSession;
import
org.apache.shardingsphere.proxy.backend.session.ServerPreparedStatementRegistry;
-import
org.apache.shardingsphere.proxy.frontend.postgresql.ProxyContextRestorer;
import
org.apache.shardingsphere.proxy.frontend.postgresql.command.query.extended.PostgreSQLServerPreparedStatement;
import
org.apache.shardingsphere.sql.parser.sql.common.statement.dal.EmptyStatement;
import
org.apache.shardingsphere.sql.parser.sql.dialect.statement.postgresql.dml.PostgreSQLInsertStatement;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
-import org.mockito.Answers;
import org.mockito.InjectMocks;
import org.mockito.Mock;
+import org.mockito.MockedStatic;
import org.mockito.internal.configuration.plugins.Plugins;
import org.mockito.junit.MockitoJUnitRunner;
@@ -54,12 +53,13 @@ import java.util.Collections;
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
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;
@RunWith(MockitoJUnitRunner.class)
-public final class PostgreSQLComParseExecutorTest extends ProxyContextRestorer
{
-
- private final ShardingSphereRuleMetaData globalRuleMetaData = new
ShardingSphereRuleMetaData(Collections.singleton(new SQLParserRule(new
DefaultSQLParserRuleConfigurationBuilder().build())));
+public final class PostgreSQLComParseExecutorTest {
@Mock
private PostgreSQLComParsePacket parsePacket;
@@ -70,13 +70,10 @@ public final class PostgreSQLComParseExecutorTest extends
ProxyContextRestorer {
@InjectMocks
private PostgreSQLComParseExecutor executor;
- @Mock(answer = Answers.RETURNS_DEEP_STUBS)
- private ContextManager mockedContextManager;
-
@Before
public void setup() {
- ProxyContext.init(mockedContextManager);
when(connectionSession.getServerPreparedStatementRegistry()).thenReturn(new
ServerPreparedStatementRegistry());
+ when(connectionSession.getDatabaseName()).thenReturn("db");
}
@Test
@@ -85,19 +82,18 @@ public final class PostgreSQLComParseExecutorTest extends
ProxyContextRestorer {
final String statementId = "S_1";
when(parsePacket.getSql()).thenReturn(expectedSQL);
when(parsePacket.getStatementId()).thenReturn(statementId);
- when(connectionSession.getDatabaseName()).thenReturn("db");
-
when(mockedContextManager.getMetaDataContexts().getMetaData().getDatabase("db").getResourceMetaData().getStorageTypes())
- .thenReturn(Collections.singletonMap("ds_0", new
PostgreSQLDatabaseType()));
-
when(mockedContextManager.getMetaDataContexts().getMetaData().getDatabase("db").getProtocolType()).thenReturn(new
PostgreSQLDatabaseType());
-
when(mockedContextManager.getMetaDataContexts().getMetaData().getGlobalRuleMetaData()).thenReturn(globalRuleMetaData);
- Collection<DatabasePacket<?>> actualPackets = executor.execute();
- assertThat(actualPackets.size(), is(1));
- assertThat(actualPackets.iterator().next(),
is(PostgreSQLParseCompletePacket.getInstance()));
- PostgreSQLServerPreparedStatement actualPreparedStatement =
connectionSession.getServerPreparedStatementRegistry().getPreparedStatement(statementId);
- assertThat(actualPreparedStatement.getSqlStatementContext(),
instanceOf(CommonSQLStatementContext.class));
-
assertThat(actualPreparedStatement.getSqlStatementContext().getSqlStatement(),
instanceOf(EmptyStatement.class));
- assertThat(actualPreparedStatement.getSql(), is(expectedSQL));
- assertThat(actualPreparedStatement.getParameterTypes(),
is(Collections.emptyList()));
+ ContextManager contextManager = mockContextManager();
+ try (MockedStatic<ProxyContext> proxyContext =
mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
+ proxyContext.when(() ->
ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ Collection<DatabasePacket<?>> actualPackets = executor.execute();
+ assertThat(actualPackets.size(), is(1));
+ assertThat(actualPackets.iterator().next(),
is(PostgreSQLParseCompletePacket.getInstance()));
+ PostgreSQLServerPreparedStatement actualPreparedStatement =
connectionSession.getServerPreparedStatementRegistry().getPreparedStatement(statementId);
+ assertThat(actualPreparedStatement.getSqlStatementContext(),
instanceOf(CommonSQLStatementContext.class));
+
assertThat(actualPreparedStatement.getSqlStatementContext().getSqlStatement(),
instanceOf(EmptyStatement.class));
+ assertThat(actualPreparedStatement.getSql(), is(expectedSQL));
+ assertThat(actualPreparedStatement.getParameterTypes(),
is(Collections.emptyList()));
+ }
}
@Test
@@ -108,21 +104,20 @@ public final class PostgreSQLComParseExecutorTest extends
ProxyContextRestorer {
when(parsePacket.getSql()).thenReturn(rawSQL);
when(parsePacket.getStatementId()).thenReturn(statementId);
when(parsePacket.readParameterTypes()).thenReturn(Collections.singletonList(PostgreSQLColumnType.POSTGRESQL_TYPE_INT4));
-
when(mockedContextManager.getMetaDataContexts().getMetaData().getDatabase("db").getResourceMetaData().getStorageTypes())
- .thenReturn(Collections.singletonMap("ds_0", new
PostgreSQLDatabaseType()));
-
when(mockedContextManager.getMetaDataContexts().getMetaData().getDatabase("db").getProtocolType()).thenReturn(new
PostgreSQLDatabaseType());
-
when(mockedContextManager.getMetaDataContexts().getMetaData().getGlobalRuleMetaData()).thenReturn(globalRuleMetaData);
when(connectionSession.getDefaultDatabaseName()).thenReturn("db");
- when(connectionSession.getDatabaseName()).thenReturn("db");
setConnectionSession();
- Collection<DatabasePacket<?>> actualPackets = executor.execute();
- assertThat(actualPackets.size(), is(1));
- assertThat(actualPackets.iterator().next(),
is(PostgreSQLParseCompletePacket.getInstance()));
- PostgreSQLServerPreparedStatement actualPreparedStatement =
connectionSession.getServerPreparedStatementRegistry().getPreparedStatement(statementId);
- assertThat(actualPreparedStatement.getSqlStatementContext(),
instanceOf(InsertStatementContext.class));
-
assertThat(actualPreparedStatement.getSqlStatementContext().getSqlStatement(),
instanceOf(PostgreSQLInsertStatement.class));
- assertThat(actualPreparedStatement.getSql(), is(expectedSQL));
- assertThat(actualPreparedStatement.getParameterTypes(),
is(Arrays.asList(PostgreSQLColumnType.POSTGRESQL_TYPE_INT4,
PostgreSQLColumnType.POSTGRESQL_TYPE_UNSPECIFIED)));
+ ContextManager contextManager = mockContextManager();
+ try (MockedStatic<ProxyContext> proxyContext =
mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
+ proxyContext.when(() ->
ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ Collection<DatabasePacket<?>> actualPackets = executor.execute();
+ assertThat(actualPackets.size(), is(1));
+ assertThat(actualPackets.iterator().next(),
is(PostgreSQLParseCompletePacket.getInstance()));
+ PostgreSQLServerPreparedStatement actualPreparedStatement =
connectionSession.getServerPreparedStatementRegistry().getPreparedStatement(statementId);
+ assertThat(actualPreparedStatement.getSqlStatementContext(),
instanceOf(InsertStatementContext.class));
+
assertThat(actualPreparedStatement.getSqlStatementContext().getSqlStatement(),
instanceOf(PostgreSQLInsertStatement.class));
+ assertThat(actualPreparedStatement.getSql(), is(expectedSQL));
+ assertThat(actualPreparedStatement.getParameterTypes(),
is(Arrays.asList(PostgreSQLColumnType.POSTGRESQL_TYPE_INT4,
PostgreSQLColumnType.POSTGRESQL_TYPE_UNSPECIFIED)));
+ }
}
@SneakyThrows(ReflectiveOperationException.class)
@@ -136,18 +131,26 @@ public final class PostgreSQLComParseExecutorTest extends
ProxyContextRestorer {
String statementId = "";
when(parsePacket.getSql()).thenReturn(sql);
when(parsePacket.getStatementId()).thenReturn(statementId);
- when(connectionSession.getDatabaseName()).thenReturn("db");
-
when(mockedContextManager.getMetaDataContexts().getMetaData().getDatabase("db").getResourceMetaData().getStorageTypes())
- .thenReturn(Collections.singletonMap("ds_0", new
PostgreSQLDatabaseType()));
-
when(mockedContextManager.getMetaDataContexts().getMetaData().getDatabase("db").getProtocolType()).thenReturn(new
PostgreSQLDatabaseType());
-
when(mockedContextManager.getMetaDataContexts().getMetaData().getGlobalRuleMetaData()).thenReturn(globalRuleMetaData);
- Collection<DatabasePacket<?>> actualPackets = executor.execute();
- assertThat(actualPackets.size(), is(1));
- assertThat(actualPackets.iterator().next(),
is(PostgreSQLParseCompletePacket.getInstance()));
- PostgreSQLServerPreparedStatement actualPreparedStatement =
connectionSession.getServerPreparedStatementRegistry().getPreparedStatement(statementId);
- assertThat(actualPreparedStatement.getSql(), is(sql));
- assertThat(actualPreparedStatement.getSqlStatementContext(),
instanceOf(DistSQLStatementContext.class));
-
assertThat(actualPreparedStatement.getSqlStatementContext().getSqlStatement(),
instanceOf(ShowDistVariableStatement.class));
- assertThat(actualPreparedStatement.getParameterTypes(),
is(Collections.emptyList()));
+ ContextManager contextManager = mockContextManager();
+ try (MockedStatic<ProxyContext> proxyContext =
mockStatic(ProxyContext.class, RETURNS_DEEP_STUBS)) {
+ proxyContext.when(() ->
ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
+ Collection<DatabasePacket<?>> actualPackets = executor.execute();
+ assertThat(actualPackets.size(), is(1));
+ assertThat(actualPackets.iterator().next(),
is(PostgreSQLParseCompletePacket.getInstance()));
+ PostgreSQLServerPreparedStatement actualPreparedStatement =
connectionSession.getServerPreparedStatementRegistry().getPreparedStatement(statementId);
+ assertThat(actualPreparedStatement.getSql(), is(sql));
+ assertThat(actualPreparedStatement.getSqlStatementContext(),
instanceOf(DistSQLStatementContext.class));
+
assertThat(actualPreparedStatement.getSqlStatementContext().getSqlStatement(),
instanceOf(ShowDistVariableStatement.class));
+ assertThat(actualPreparedStatement.getParameterTypes(),
is(Collections.emptyList()));
+ }
+ }
+
+ private ContextManager mockContextManager() {
+ ContextManager result = mock(ContextManager.class, RETURNS_DEEP_STUBS);
+
when(result.getMetaDataContexts().getMetaData().getDatabase("db").getResourceMetaData().getStorageTypes()).thenReturn(Collections.singletonMap("ds_0",
new PostgreSQLDatabaseType()));
+
when(result.getMetaDataContexts().getMetaData().getDatabase("db").getProtocolType()).thenReturn(new
PostgreSQLDatabaseType());
+
when(result.getMetaDataContexts().getMetaData().getGlobalRuleMetaData())
+ .thenReturn(new
ShardingSphereRuleMetaData(Collections.singleton(new SQLParserRule(new
DefaultSQLParserRuleConfigurationBuilder().build()))));
+ return result;
}
}
