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 26a28f8378d Refactor SetDefaultSingleTableStorageUnitExecutorTest
(#33098)
26a28f8378d is described below
commit 26a28f8378df25b1786483e2f422ed03203565c4
Author: Liang Zhang <[email protected]>
AuthorDate: Wed Oct 2 17:01:39 2024 +0800
Refactor SetDefaultSingleTableStorageUnitExecutorTest (#33098)
---
.../SetDefaultSingleTableStorageUnitExecutor.java | 32 +++-----
...tDefaultSingleTableStorageUnitExecutorTest.java | 92 +++++++++++-----------
2 files changed, 59 insertions(+), 65 deletions(-)
diff --git
a/kernel/single/distsql/handler/src/main/java/org/apache/shardingsphere/single/distsql/handler/update/SetDefaultSingleTableStorageUnitExecutor.java
b/kernel/single/distsql/handler/src/main/java/org/apache/shardingsphere/single/distsql/handler/update/SetDefaultSingleTableStorageUnitExecutor.java
index 708cebe3aca..20c98b931cc 100644
---
a/kernel/single/distsql/handler/src/main/java/org/apache/shardingsphere/single/distsql/handler/update/SetDefaultSingleTableStorageUnitExecutor.java
+++
b/kernel/single/distsql/handler/src/main/java/org/apache/shardingsphere/single/distsql/handler/update/SetDefaultSingleTableStorageUnitExecutor.java
@@ -31,6 +31,7 @@ import org.apache.shardingsphere.single.rule.SingleRule;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
+import java.util.LinkedList;
import java.util.stream.Collectors;
/**
@@ -45,42 +46,31 @@ public final class SetDefaultSingleTableStorageUnitExecutor
implements DatabaseR
@Override
public void checkBeforeUpdate(final
SetDefaultSingleTableStorageUnitStatement sqlStatement) {
- checkStorageUnitExist(sqlStatement);
+ checkDefaultStorageUnitExist(sqlStatement);
}
- private void checkStorageUnitExist(final
SetDefaultSingleTableStorageUnitStatement sqlStatement) {
+ private void checkDefaultStorageUnitExist(final
SetDefaultSingleTableStorageUnitStatement sqlStatement) {
if (!Strings.isNullOrEmpty(sqlStatement.getDefaultStorageUnit())) {
- Collection<String> dataSourceNames = new
HashSet<>(database.getResourceMetaData().getStorageUnits().keySet());
- dataSourceNames.addAll(getLogicDataSourceNames());
- ShardingSpherePreconditions.checkContains(dataSourceNames,
sqlStatement.getDefaultStorageUnit(),
+
ShardingSpherePreconditions.checkContains(getAllStorageUnitNames(),
sqlStatement.getDefaultStorageUnit(),
() -> new
MissingRequiredStorageUnitsException(database.getName(),
Collections.singleton(sqlStatement.getDefaultStorageUnit())));
}
}
- private Collection<String> getLogicDataSourceNames() {
- return
database.getRuleMetaData().getAttributes(DataSourceMapperRuleAttribute.class).stream()
- .flatMap(each ->
each.getDataSourceMapper().keySet().stream()).collect(Collectors.toSet());
+ private Collection<String> getAllStorageUnitNames() {
+ Collection<String> result = new
HashSet<>(database.getResourceMetaData().getStorageUnits().keySet());
+ result.addAll(
+
database.getRuleMetaData().getAttributes(DataSourceMapperRuleAttribute.class).stream().flatMap(each
-> each.getDataSourceMapper().keySet().stream()).collect(Collectors.toSet()));
+ return result;
}
@Override
public SingleRuleConfiguration buildToBeAlteredRuleConfiguration(final
SetDefaultSingleTableStorageUnitStatement sqlStatement) {
- SingleRuleConfiguration result = new SingleRuleConfiguration();
- if (null != sqlStatement.getDefaultStorageUnit()) {
- result.setDefaultDataSource(sqlStatement.getDefaultStorageUnit());
- }
- return result;
+ return new SingleRuleConfiguration(new LinkedList<>(),
sqlStatement.getDefaultStorageUnit());
}
@Override
public SingleRuleConfiguration buildToBeDroppedRuleConfiguration(final
SingleRuleConfiguration toBeAlteredRuleConfig) {
- if (toBeAlteredRuleConfig.getDefaultDataSource().isPresent()) {
- return null;
- }
- SingleRuleConfiguration result = new SingleRuleConfiguration();
- if (rule.getConfiguration().getDefaultDataSource().isPresent()) {
-
result.setDefaultDataSource(rule.getConfiguration().getDefaultDataSource().get());
- }
- return result;
+ return toBeAlteredRuleConfig.getDefaultDataSource().isPresent() ? null
: new SingleRuleConfiguration(new LinkedList<>(),
rule.getConfiguration().getDefaultDataSource().orElse(null));
}
@Override
diff --git
a/kernel/single/distsql/handler/src/test/java/org/apache/shardingsphere/single/distsql/handler/update/SetDefaultSingleTableStorageUnitExecutorTest.java
b/kernel/single/distsql/handler/src/test/java/org/apache/shardingsphere/single/distsql/handler/update/SetDefaultSingleTableStorageUnitExecutorTest.java
index 979ea776070..487c43d0650 100644
---
a/kernel/single/distsql/handler/src/test/java/org/apache/shardingsphere/single/distsql/handler/update/SetDefaultSingleTableStorageUnitExecutorTest.java
+++
b/kernel/single/distsql/handler/src/test/java/org/apache/shardingsphere/single/distsql/handler/update/SetDefaultSingleTableStorageUnitExecutorTest.java
@@ -17,77 +17,81 @@
package org.apache.shardingsphere.single.distsql.handler.update;
+import
org.apache.shardingsphere.distsql.handler.engine.update.DistSQLUpdateExecuteEngine;
import
org.apache.shardingsphere.infra.exception.kernel.metadata.resource.storageunit.MissingRequiredStorageUnitsException;
import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
+import org.apache.shardingsphere.infra.metadata.database.rule.RuleMetaData;
import
org.apache.shardingsphere.infra.rule.attribute.datasource.DataSourceMapperRuleAttribute;
+import org.apache.shardingsphere.mode.manager.ContextManager;
+import
org.apache.shardingsphere.mode.persist.service.MetaDataManagerPersistService;
import org.apache.shardingsphere.single.config.SingleRuleConfiguration;
import
org.apache.shardingsphere.single.distsql.statement.rdl.SetDefaultSingleTableStorageUnitStatement;
import org.apache.shardingsphere.single.rule.SingleRule;
import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.ArgumentMatchers;
+import java.sql.SQLException;
+import java.util.Arrays;
import java.util.Collections;
+import java.util.HashSet;
+import java.util.Optional;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.mockito.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.verify;
import static org.mockito.Mockito.when;
-@ExtendWith(MockitoExtension.class)
class SetDefaultSingleTableStorageUnitExecutorTest {
- private final SetDefaultSingleTableStorageUnitExecutor executor = new
SetDefaultSingleTableStorageUnitExecutor();
-
@Test
- void assertCheckWithInvalidDataSource() {
+ void assertExecuteUpdateWithNotExistedDefaultStorageUnit() {
ShardingSphereDatabase database = mock(ShardingSphereDatabase.class,
RETURNS_DEEP_STUBS);
-
when(database.getRuleMetaData().getAttributes(any())).thenReturn(Collections.emptyList());
- executor.setDatabase(database);
- assertThrows(MissingRequiredStorageUnitsException.class, () ->
executor.checkBeforeUpdate(new
SetDefaultSingleTableStorageUnitStatement("bar_ds")));
+
when(database.getResourceMetaData().getStorageUnits().keySet()).thenReturn(Collections.emptySet());
+
when(database.getRuleMetaData().getAttributes(DataSourceMapperRuleAttribute.class)).thenReturn(Collections.emptyList());
+ SingleRule rule = mock(SingleRule.class, RETURNS_DEEP_STUBS);
+
when(rule.getAttributes().findAttribute(DataSourceMapperRuleAttribute.class)).thenReturn(Optional.empty());
+ DistSQLUpdateExecuteEngine engine = new DistSQLUpdateExecuteEngine(new
SetDefaultSingleTableStorageUnitStatement("foo_ds"), "foo_db",
mockContextManager(rule, database));
+ assertThrows(MissingRequiredStorageUnitsException.class,
engine::executeUpdate);
}
@Test
- void assertCheckWithLogicDataSource() {
+ void assertExecuteUpdateWithoutDefaultStorageUnit() throws SQLException {
+ SingleRule rule = mock(SingleRule.class);
+ when(rule.getConfiguration()).thenReturn(new
SingleRuleConfiguration(Collections.emptyList(), "foo_ds"));
ShardingSphereDatabase database = mock(ShardingSphereDatabase.class,
RETURNS_DEEP_STUBS);
- DataSourceMapperRuleAttribute ruleAttribute =
mock(DataSourceMapperRuleAttribute.class, RETURNS_DEEP_STUBS);
-
when(ruleAttribute.getDataSourceMapper().keySet()).thenReturn(Collections.singleton("logic_ds"));
-
when(database.getRuleMetaData().getAttributes(any())).thenReturn(Collections.singleton(ruleAttribute));
- executor.setDatabase(database);
- assertDoesNotThrow(() -> executor.checkBeforeUpdate(new
SetDefaultSingleTableStorageUnitStatement("logic_ds")));
+ ContextManager contextManager = mockContextManager(rule, database);
+ DistSQLUpdateExecuteEngine engine = new DistSQLUpdateExecuteEngine(new
SetDefaultSingleTableStorageUnitStatement(null), "foo_db", contextManager);
+ engine.executeUpdate();
+ MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
+ verify(metaDataManagerPersistService)
+ .removeRuleConfigurationItem(eq("foo_db"),
ArgumentMatchers.<SingleRuleConfiguration>argThat(x ->
x.getDefaultDataSource().equals(Optional.of("foo_ds"))));
+
verify(metaDataManagerPersistService).alterRuleConfiguration(eq("foo_db"),
ArgumentMatchers.<SingleRuleConfiguration>argThat(x ->
!x.getDefaultDataSource().isPresent()));
}
@Test
- void assertUpdate() {
- executor.setRule(mock(SingleRule.class));
- SingleRuleConfiguration toBeAlteredRuleConfig =
executor.buildToBeAlteredRuleConfiguration(new
SetDefaultSingleTableStorageUnitStatement("foo_ds"));
- assertTrue(toBeAlteredRuleConfig.getDefaultDataSource().isPresent());
- assertThat(toBeAlteredRuleConfig.getDefaultDataSource().get(),
is("foo_ds"));
- assertTrue(toBeAlteredRuleConfig.getTables().isEmpty());
-
assertNull(executor.buildToBeDroppedRuleConfiguration(toBeAlteredRuleConfig));
+ void assertExecuteUpdateWithDefaultStorageUnit() throws SQLException {
+ SingleRule rule = mock(SingleRule.class, RETURNS_DEEP_STUBS);
+ when(rule.getConfiguration()).thenReturn(new
SingleRuleConfiguration(Collections.emptyList(), "foo_ds"));
+
when(rule.getAttributes().findAttribute(DataSourceMapperRuleAttribute.class)).thenReturn(Optional.empty());
+ ShardingSphereDatabase database = mock(ShardingSphereDatabase.class,
RETURNS_DEEP_STUBS);
+
when(database.getResourceMetaData().getStorageUnits().keySet()).thenReturn(new
HashSet<>(Arrays.asList("foo_ds", "bar_ds")));
+
when(database.getRuleMetaData().getAttributes(DataSourceMapperRuleAttribute.class)).thenReturn(Collections.emptyList());
+ ContextManager contextManager = mockContextManager(rule, database);
+ DistSQLUpdateExecuteEngine engine = new DistSQLUpdateExecuteEngine(new
SetDefaultSingleTableStorageUnitStatement("bar_ds"), "foo_db", contextManager);
+ engine.executeUpdate();
+ MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
+
verify(metaDataManagerPersistService).removeRuleConfigurationItem("foo_db",
null);
+
verify(metaDataManagerPersistService).alterRuleConfiguration(eq("foo_db"),
ArgumentMatchers.<SingleRuleConfiguration>argThat(x ->
x.getDefaultDataSource().equals(Optional.of("bar_ds"))));
}
- @Test
- void assertRandom() {
- SingleRuleConfiguration currentConfig = new SingleRuleConfiguration();
- currentConfig.setDefaultDataSource("foo_ds");
- SingleRule rule = mock(SingleRule.class);
- when(rule.getConfiguration()).thenReturn(currentConfig);
- executor.setRule(rule);
- SingleRuleConfiguration toBeAlteredRuleConfig =
executor.buildToBeAlteredRuleConfiguration(new
SetDefaultSingleTableStorageUnitStatement(null));
- assertFalse(toBeAlteredRuleConfig.getDefaultDataSource().isPresent());
- SingleRuleConfiguration toBeDroppedRuleConfig =
executor.buildToBeDroppedRuleConfiguration(toBeAlteredRuleConfig);
- assertNotNull(toBeDroppedRuleConfig);
- assertTrue(toBeDroppedRuleConfig.getDefaultDataSource().isPresent());
- assertThat(toBeDroppedRuleConfig.getDefaultDataSource().get(),
is("foo_ds"));
- assertTrue(toBeDroppedRuleConfig.getTables().isEmpty());
+ private ContextManager mockContextManager(final SingleRule rule, final
ShardingSphereDatabase database) {
+ ContextManager result = mock(ContextManager.class, RETURNS_DEEP_STUBS);
+ RuleMetaData ruleMetaData = new
RuleMetaData(Collections.singleton(rule));
+ when(database.getName()).thenReturn("foo_db");
+ when(database.getRuleMetaData()).thenReturn(ruleMetaData);
+ when(result.getDatabase("foo_db")).thenReturn(database);
+ return result;
}
}
