This is an automated email from the ASF dual-hosted git repository.
duanzhengqiang 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 b043275499c Use MockResourceAutoReleaseExtension on feature modules
(#24370)
b043275499c is described below
commit b043275499ce08ae0da55e6144f8aa67f6e3140e
Author: Liang Zhang <[email protected]>
AuthorDate: Tue Feb 28 12:31:21 2023 +0800
Use MockResourceAutoReleaseExtension on feature modules (#24370)
* Use junit 5 on mysql protocol module
* Add MockResourceAutoReleaseExtension
* Add MockResourceAutoReleaseExtension
* Add MockResourceAutoReleaseExtension
* Use MockResourceAutoReleaseExtension on agent modules
* Use MockResourceAutoReleaseExtension on feature modules
---
.../EncryptAssignmentTokenGeneratorTest.java | 67 +++++++++----------
...ReadwriteSplittingRuleStatementUpdaterTest.java | 76 +++++++++++-----------
2 files changed, 73 insertions(+), 70 deletions(-)
diff --git
a/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptAssignmentTokenGeneratorTest.java
b/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptAssignmentTokenGeneratorTest.java
index 5e6469ff407..f2edf82fa11 100644
---
a/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptAssignmentTokenGeneratorTest.java
+++
b/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptAssignmentTokenGeneratorTest.java
@@ -26,55 +26,60 @@ import
org.apache.shardingsphere.sql.parser.sql.common.segment.dml.assignment.Se
import
org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.simple.LiteralExpressionSegment;
import
org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.simple.ParameterMarkerExpressionSegment;
import
org.apache.shardingsphere.sql.parser.sql.dialect.handler.dml.InsertStatementHandler;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.MockedStatic;
+import org.apache.shardingsphere.test.mock.MockResourceAutoReleaseExtension;
+import org.apache.shardingsphere.test.mock.StaticMockSettings;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Answers;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
import java.util.Collections;
import java.util.Optional;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.mockStatic;
import static org.mockito.Mockito.when;
+@ExtendWith(MockResourceAutoReleaseExtension.class)
+@StaticMockSettings(InsertStatementHandler.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
public final class EncryptAssignmentTokenGeneratorTest {
private final EncryptAssignmentTokenGenerator tokenGenerator = new
EncryptAssignmentTokenGenerator();
+ @Mock(answer = Answers.RETURNS_DEEP_STUBS)
private UpdateStatementContext updateStatement;
+ @Mock(answer = Answers.RETURNS_DEEP_STUBS)
private InsertStatementContext insertStatement;
+ @Mock(answer = Answers.RETURNS_DEEP_STUBS)
private AssignmentSegment assignmentSegment;
+ @Mock(answer = Answers.RETURNS_DEEP_STUBS)
private SetAssignmentSegment setAssignmentSegment;
- private LiteralExpressionSegment literalExpression;
-
- private ParameterMarkerExpressionSegment parameterMarkerExpression;
-
- @Before
+ @BeforeEach
public void setup() {
- updateStatement = mock(UpdateStatementContext.class,
RETURNS_DEEP_STUBS);
- insertStatement = mock(InsertStatementContext.class,
RETURNS_DEEP_STUBS);
- assignmentSegment = mock(AssignmentSegment.class, RETURNS_DEEP_STUBS);
- setAssignmentSegment = mock(SetAssignmentSegment.class,
RETURNS_DEEP_STUBS);
- literalExpression = mock(LiteralExpressionSegment.class,
RETURNS_DEEP_STUBS);
- parameterMarkerExpression =
mock(ParameterMarkerExpressionSegment.class, RETURNS_DEEP_STUBS);
- EncryptRule encryptRule = mock(EncryptRule.class, RETURNS_DEEP_STUBS);
- tokenGenerator.setEncryptRule(encryptRule);
+ tokenGenerator.setEncryptRule(mockEncryptRule());
when(updateStatement.getAllTables().iterator().next().getTableName().getIdentifier().getValue()).thenReturn("table");
-
when(updateStatement.getSqlStatement().getSetAssignment().getAssignments()).thenReturn(Collections.singletonList(assignmentSegment));
+
when(updateStatement.getSqlStatement().getSetAssignment().getAssignments()).thenReturn(Collections.singleton(assignmentSegment));
when(assignmentSegment.getColumns().get(0).getIdentifier().getValue()).thenReturn("columns");
- when(encryptRule.findEncryptor(eq("table"),
eq("columns"))).thenReturn(Optional.of(mock(StandardEncryptAlgorithm.class)));
when(insertStatement.getAllTables().iterator().next().getTableName().getIdentifier().getValue()).thenReturn("table");
-
when(setAssignmentSegment.getAssignments()).thenReturn(Collections.singletonList(assignmentSegment));
+
when(setAssignmentSegment.getAssignments()).thenReturn(Collections.singleton(assignmentSegment));
+ }
+
+ private EncryptRule mockEncryptRule() {
+ EncryptRule result = mock(EncryptRule.class, RETURNS_DEEP_STUBS);
+ when(result.findEncryptor("table",
"columns")).thenReturn(Optional.of(mock(StandardEncryptAlgorithm.class)));
+ return result;
}
@Test
@@ -84,21 +89,19 @@ public final class EncryptAssignmentTokenGeneratorTest {
@Test
public void assertIsGenerateSQLTokenUpdateSQLFail() {
- try (MockedStatic<InsertStatementHandler>
insertStatementHandlerMockedStatic = mockStatic(InsertStatementHandler.class)) {
- insertStatementHandlerMockedStatic.when(() ->
InsertStatementHandler.getSetAssignmentSegment(any())).thenReturn(Optional.of(setAssignmentSegment));
- assertTrue(tokenGenerator.isGenerateSQLToken(insertStatement));
- }
+
when(InsertStatementHandler.getSetAssignmentSegment(any())).thenReturn(Optional.of(setAssignmentSegment));
+ assertTrue(tokenGenerator.isGenerateSQLToken(insertStatement));
}
@Test
public void
assertGenerateSQLTokenWithUpdateParameterMarkerExpressionSegment() {
-
when(assignmentSegment.getValue()).thenReturn(parameterMarkerExpression);
+
when(assignmentSegment.getValue()).thenReturn(mock(ParameterMarkerExpressionSegment.class));
assertThat(tokenGenerator.generateSQLTokens(updateStatement).size(),
is(1));
}
@Test
public void assertGenerateSQLTokenWithUpdateLiteralExpressionSegment() {
- when(assignmentSegment.getValue()).thenReturn(literalExpression);
+
when(assignmentSegment.getValue()).thenReturn(mock(LiteralExpressionSegment.class));
assertThat(tokenGenerator.generateSQLTokens(updateStatement).size(),
is(1));
}
@@ -110,10 +113,8 @@ public final class EncryptAssignmentTokenGeneratorTest {
@Test
public void assertGenerateSQLTokenWithInsertLiteralExpressionSegment() {
- try (MockedStatic<InsertStatementHandler>
insertStatementHandlerMockedStatic = mockStatic(InsertStatementHandler.class)) {
- insertStatementHandlerMockedStatic.when(() ->
InsertStatementHandler.getSetAssignmentSegment(any())).thenReturn(Optional.of(setAssignmentSegment));
- when(assignmentSegment.getValue()).thenReturn(literalExpression);
-
assertThat(tokenGenerator.generateSQLTokens(insertStatement).size(), is(1));
- }
+
when(InsertStatementHandler.getSetAssignmentSegment(any())).thenReturn(Optional.of(setAssignmentSegment));
+
when(assignmentSegment.getValue()).thenReturn(mock(LiteralExpressionSegment.class));
+ assertThat(tokenGenerator.generateSQLTokens(insertStatement).size(),
is(1));
}
}
diff --git
a/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/CreateReadwriteSplittingRuleStatementUpdaterTest.java
b/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/CreateReadwriteSplittingRuleStatementUpdaterTest.java
index 59aa8f998ac..27a22312079 100644
---
a/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/CreateReadwriteSplittingRuleStatementUpdaterTest.java
+++
b/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/CreateReadwriteSplittingRuleStatementUpdaterTest.java
@@ -32,13 +32,13 @@ import
org.apache.shardingsphere.readwritesplitting.api.strategy.StaticReadwrite
import
org.apache.shardingsphere.readwritesplitting.distsql.parser.segment.ReadwriteSplittingRuleSegment;
import
org.apache.shardingsphere.readwritesplitting.distsql.parser.statement.CreateReadwriteSplittingRuleStatement;
import
org.apache.shardingsphere.readwritesplitting.spi.ReadQueryLoadBalanceAlgorithm;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.apache.shardingsphere.test.mock.MockResourceAutoReleaseExtension;
+import org.apache.shardingsphere.test.mock.StaticMockSettings;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Answers;
import org.mockito.Mock;
-import org.mockito.MockedStatic;
-import org.mockito.junit.MockitoJUnitRunner;
import java.util.ArrayList;
import java.util.Arrays;
@@ -50,12 +50,13 @@ import java.util.Properties;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.mockStatic;
import static org.mockito.Mockito.when;
-@RunWith(MockitoJUnitRunner.class)
+@ExtendWith(MockResourceAutoReleaseExtension.class)
+@StaticMockSettings(TypedSPILoader.class)
public final class CreateReadwriteSplittingRuleStatementUpdaterTest {
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
@@ -66,62 +67,65 @@ public final class
CreateReadwriteSplittingRuleStatementUpdaterTest {
private final CreateReadwriteSplittingRuleStatementUpdater updater = new
CreateReadwriteSplittingRuleStatementUpdater();
- @Before
+ @BeforeEach
public void before() {
when(database.getResourceMetaData()).thenReturn(resourceMetaData);
}
- @Test(expected = DuplicateRuleException.class)
+ @Test
public void assertCheckSQLStatementWithDuplicateRuleNames() {
when(resourceMetaData.getDataSources()).thenReturn(Collections.emptyMap());
- updater.checkSQLStatement(database, createSQLStatement("TEST"),
createCurrentRuleConfiguration());
+ assertThrows(DuplicateRuleException.class, () ->
updater.checkSQLStatement(database, createSQLStatement("TEST"),
createCurrentRuleConfiguration()));
}
- @Test(expected = InvalidRuleConfigurationException.class)
+ @Test
public void assertCheckSQLStatementWithDuplicateResource() {
when(resourceMetaData.getDataSources()).thenReturn(Collections.singletonMap("write_ds",
null));
- updater.checkSQLStatement(database, createSQLStatement("write_ds",
"TEST"), createCurrentRuleConfiguration());
+ assertThrows(InvalidRuleConfigurationException.class, () ->
updater.checkSQLStatement(database, createSQLStatement("write_ds", "TEST"),
createCurrentRuleConfiguration()));
}
- @Test(expected = MissingRequiredStorageUnitsException.class)
+ @Test
public void assertCheckSQLStatementWithoutExistedResources() {
when(resourceMetaData.getNotExistedDataSources(any())).thenReturn(Arrays.asList("read_ds_0",
"read_ds_1"));
- updater.checkSQLStatement(database, createSQLStatement("TEST"), null);
+ assertThrows(MissingRequiredStorageUnitsException.class, () ->
updater.checkSQLStatement(database, createSQLStatement("TEST"), null));
}
- @Test(expected = MissingRequiredStorageUnitsException.class)
+ @Test
public void assertCheckSQLStatementWithoutExistedAutoAwareResources() {
ExportableRule exportableRule = mock(ExportableRule.class);
when(exportableRule.getExportData()).thenReturn(Collections.singletonMap(ExportableConstants.EXPORT_DB_DISCOVERY_PRIMARY_DATA_SOURCES,
Collections.singletonMap("ms_group", "ds_0")));
when(database.getRuleMetaData().findRules(ExportableRule.class)).thenReturn(Collections.singleton(exportableRule));
ReadwriteSplittingRuleSegment ruleSegment = new
ReadwriteSplittingRuleSegment("dynamic_rule", "ha_group", "false", "TEST", new
Properties());
- updater.checkSQLStatement(database, createSQLStatement(false,
ruleSegment), null);
+ assertThrows(MissingRequiredStorageUnitsException.class, () ->
updater.checkSQLStatement(database, createSQLStatement(false, ruleSegment),
null));
}
- @Test(expected = InvalidAlgorithmConfigurationException.class)
+ @Test
public void assertCheckSQLStatementWithoutToBeCreatedLoadBalancers() {
when(database.getRuleMetaData().findRules(any())).thenReturn(Collections.emptyList());
- updater.checkSQLStatement(database,
createSQLStatement("INVALID_TYPE"), null);
+ assertThrows(InvalidAlgorithmConfigurationException.class, () ->
updater.checkSQLStatement(database, createSQLStatement("INVALID_TYPE"), null));
}
- @Test(expected = InvalidRuleConfigurationException.class)
+ @Test
public void
assertCheckSQLStatementWithDuplicateWriteResourceNamesInStatement() {
- updater.checkSQLStatement(database,
createSQLStatementWithDuplicateWriteResourceNames("write_ds_0", "write_ds_1",
"TEST"), null);
+ assertThrows(InvalidRuleConfigurationException.class,
+ () -> updater.checkSQLStatement(database,
createSQLStatementWithDuplicateWriteResourceNames("write_ds_0", "write_ds_1",
"TEST"), null));
}
- @Test(expected = InvalidRuleConfigurationException.class)
+ @Test
public void assertCheckSQLStatementWithDuplicateWriteResourceNames() {
- updater.checkSQLStatement(database,
createSQLStatement("readwrite_ds_1", "ds_write", Arrays.asList("read_ds_0",
"read_ds_1"), "TEST"), createCurrentRuleConfiguration());
+ assertThrows(InvalidRuleConfigurationException.class,
+ () -> updater.checkSQLStatement(database,
createSQLStatement("readwrite_ds_1", "ds_write", Arrays.asList("read_ds_0",
"read_ds_1"), "TEST"), createCurrentRuleConfiguration()));
}
- @Test(expected = InvalidRuleConfigurationException.class)
+ @Test
public void
assertCheckSQLStatementWithDuplicateReadResourceNamesInStatement() {
- updater.checkSQLStatement(database,
createSQLStatementWithDuplicateReadResourceNames("write_ds_0", "write_ds_1",
"TEST"), null);
+ assertThrows(InvalidRuleConfigurationException.class, () ->
updater.checkSQLStatement(database,
createSQLStatementWithDuplicateReadResourceNames("write_ds_0", "write_ds_1",
"TEST"), null));
}
- @Test(expected = InvalidRuleConfigurationException.class)
+ @Test
public void assertCheckSQLStatementWithDuplicateReadResourceNames() {
- updater.checkSQLStatement(database,
createSQLStatement("readwrite_ds_1", "write_ds_1", Arrays.asList("read_ds_0",
"read_ds_1"), "TEST"), createCurrentRuleConfiguration());
+ assertThrows(InvalidRuleConfigurationException.class,
+ () -> updater.checkSQLStatement(database,
createSQLStatement("readwrite_ds_1", "write_ds_1", Arrays.asList("read_ds_0",
"read_ds_1"), "TEST"), createCurrentRuleConfiguration()));
}
@Test
@@ -135,17 +139,15 @@ public final class
CreateReadwriteSplittingRuleStatementUpdaterTest {
ExportableRule exportableRule = mock(ExportableRule.class);
when(exportableRule.getExportData()).thenReturn(Collections.singletonMap(ExportableConstants.EXPORT_DB_DISCOVERY_PRIMARY_DATA_SOURCES,
Collections.singletonMap("ms_group", "ds_0")));
when(database.getRuleMetaData().findRules(ExportableRule.class)).thenReturn(Collections.singleton(exportableRule));
- try (MockedStatic<TypedSPILoader> typedSPILoader =
mockStatic(TypedSPILoader.class)) {
- typedSPILoader.when(() ->
TypedSPILoader.contains(ReadQueryLoadBalanceAlgorithm.class,
"TEST")).thenReturn(true);
- ReadwriteSplittingRuleSegment dynamicSegment = new
ReadwriteSplittingRuleSegment("dynamic_rule", "ms_group", "false", "TEST", new
Properties());
- ReadwriteSplittingRuleSegment staticSegment = new
ReadwriteSplittingRuleSegment("static_rule", "write_ds_0",
Arrays.asList("read_ds_0", "read_ds_1"), "TEST", new Properties());
- CreateReadwriteSplittingRuleStatement statement =
createSQLStatement(false, dynamicSegment, staticSegment);
- updater.checkSQLStatement(database, statement, null);
- ReadwriteSplittingRuleConfiguration currentRuleConfig = new
ReadwriteSplittingRuleConfiguration(new ArrayList<>(), new HashMap<>());
- ReadwriteSplittingRuleConfiguration toBeCreatedRuleConfig =
updater.buildToBeCreatedRuleConfiguration(currentRuleConfig, statement);
- updater.updateCurrentRuleConfiguration(currentRuleConfig,
toBeCreatedRuleConfig);
- assertThat(currentRuleConfig.getDataSources().size(), is(2));
- }
+ when(TypedSPILoader.contains(ReadQueryLoadBalanceAlgorithm.class,
"TEST")).thenReturn(true);
+ ReadwriteSplittingRuleSegment dynamicSegment = new
ReadwriteSplittingRuleSegment("dynamic_rule", "ms_group", "false", "TEST", new
Properties());
+ ReadwriteSplittingRuleSegment staticSegment = new
ReadwriteSplittingRuleSegment("static_rule", "write_ds_0",
Arrays.asList("read_ds_0", "read_ds_1"), "TEST", new Properties());
+ CreateReadwriteSplittingRuleStatement statement =
createSQLStatement(false, dynamicSegment, staticSegment);
+ updater.checkSQLStatement(database, statement, null);
+ ReadwriteSplittingRuleConfiguration currentRuleConfig = new
ReadwriteSplittingRuleConfiguration(new ArrayList<>(), new HashMap<>());
+ ReadwriteSplittingRuleConfiguration toBeCreatedRuleConfig =
updater.buildToBeCreatedRuleConfiguration(currentRuleConfig, statement);
+ updater.updateCurrentRuleConfiguration(currentRuleConfig,
toBeCreatedRuleConfig);
+ assertThat(currentRuleConfig.getDataSources().size(), is(2));
}
private CreateReadwriteSplittingRuleStatement createSQLStatement(final
String loadBalancerName) {
