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 f5127afc4ae Add test cases of CreateBroadcastTableRuleExecutor (#33107)
f5127afc4ae is described below
commit f5127afc4ae70e43e72708ac0bd3cabea11841e2
Author: Liang Zhang <[email protected]>
AuthorDate: Thu Oct 3 18:05:02 2024 +0800
Add test cases of CreateBroadcastTableRuleExecutor (#33107)
---
.../update/CreateBroadcastTableRuleExecutor.java | 3 +-
.../CreateBroadcastTableRuleExecutorTest.java | 90 ++++++++++++++--------
...tDefaultSingleTableStorageUnitExecutorTest.java | 16 ++--
3 files changed, 66 insertions(+), 43 deletions(-)
diff --git
a/features/broadcast/distsql/handler/src/main/java/org/apache/shardingsphere/broadcast/distsql/handler/update/CreateBroadcastTableRuleExecutor.java
b/features/broadcast/distsql/handler/src/main/java/org/apache/shardingsphere/broadcast/distsql/handler/update/CreateBroadcastTableRuleExecutor.java
index a9b4c82e455..4a15ede2a42 100644
---
a/features/broadcast/distsql/handler/src/main/java/org/apache/shardingsphere/broadcast/distsql/handler/update/CreateBroadcastTableRuleExecutor.java
+++
b/features/broadcast/distsql/handler/src/main/java/org/apache/shardingsphere/broadcast/distsql/handler/update/CreateBroadcastTableRuleExecutor.java
@@ -50,8 +50,7 @@ public final class CreateBroadcastTableRuleExecutor
implements DatabaseRuleCreat
}
private void checkDuplicate(final CreateBroadcastTableRuleStatement
sqlStatement) {
- Collection<String> duplicatedRuleNames =
getDuplicatedRuleNames(sqlStatement);
- ShardingSpherePreconditions.checkMustEmpty(duplicatedRuleNames, () ->
new DuplicateRuleException("Broadcast", sqlStatement.getTables()));
+
ShardingSpherePreconditions.checkMustEmpty(getDuplicatedRuleNames(sqlStatement),
() -> new DuplicateRuleException("Broadcast", sqlStatement.getTables()));
}
private Collection<String> getDuplicatedRuleNames(final
CreateBroadcastTableRuleStatement sqlStatement) {
diff --git
a/features/broadcast/distsql/handler/src/test/java/org/apache/shardingsphere/broadcast/distsql/handler/update/CreateBroadcastTableRuleExecutorTest.java
b/features/broadcast/distsql/handler/src/test/java/org/apache/shardingsphere/broadcast/distsql/handler/update/CreateBroadcastTableRuleExecutorTest.java
index 1a7089d6fbe..26ce0e839af 100644
---
a/features/broadcast/distsql/handler/src/test/java/org/apache/shardingsphere/broadcast/distsql/handler/update/CreateBroadcastTableRuleExecutorTest.java
+++
b/features/broadcast/distsql/handler/src/test/java/org/apache/shardingsphere/broadcast/distsql/handler/update/CreateBroadcastTableRuleExecutorTest.java
@@ -20,67 +20,91 @@ package
org.apache.shardingsphere.broadcast.distsql.handler.update;
import org.apache.shardingsphere.broadcast.config.BroadcastRuleConfiguration;
import
org.apache.shardingsphere.broadcast.distsql.statement.CreateBroadcastTableRuleStatement;
import org.apache.shardingsphere.broadcast.rule.BroadcastRule;
-import
org.apache.shardingsphere.infra.exception.kernel.metadata.rule.DuplicateRuleException;
+import
org.apache.shardingsphere.distsql.handler.engine.update.DistSQLUpdateExecuteEngine;
import
org.apache.shardingsphere.infra.exception.kernel.metadata.resource.storageunit.EmptyStorageUnitException;
+import
org.apache.shardingsphere.infra.exception.kernel.metadata.rule.DuplicateRuleException;
import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
-import
org.apache.shardingsphere.infra.metadata.database.resource.unit.StorageUnit;
+import org.apache.shardingsphere.infra.metadata.database.rule.RuleMetaData;
+import org.apache.shardingsphere.mode.manager.ContextManager;
+import
org.apache.shardingsphere.mode.persist.service.MetaDataManagerPersistService;
import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentMatchers;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collections;
-import java.util.LinkedList;
+import java.util.HashSet;
-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.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;
class CreateBroadcastTableRuleExecutorTest {
- private final CreateBroadcastTableRuleExecutor executor = new
CreateBroadcastTableRuleExecutor();
+ private ContextManager mockContextManager(final ShardingSphereDatabase
database, final BroadcastRule rule) {
+ ContextManager result = mock(ContextManager.class, RETURNS_DEEP_STUBS);
+ when(database.getName()).thenReturn("foo_db");
+ when(database.getRuleMetaData()).thenReturn(new RuleMetaData(null ==
rule ? Collections.emptyList() : Collections.singleton(rule)));
+ when(result.getDatabase("foo_db")).thenReturn(database);
+ return result;
+ }
@Test
- void assertCheckSQLStatementWithEmptyStorageUnit() {
- BroadcastRuleConfiguration currentConfig =
mock(BroadcastRuleConfiguration.class);
-
when(currentConfig.getTables()).thenReturn(Collections.singleton("t_address"));
+ void assertExecuteUpdateWithEmptyStorageUnits() {
+ CreateBroadcastTableRuleStatement sqlStatement = new
CreateBroadcastTableRuleStatement(false, Collections.singleton("t_address"));
ShardingSphereDatabase database = mock(ShardingSphereDatabase.class,
RETURNS_DEEP_STUBS);
when(database.getResourceMetaData().getStorageUnits()).thenReturn(Collections.emptyMap());
- executor.setDatabase(database);
BroadcastRule rule = mock(BroadcastRule.class);
- when(rule.getConfiguration()).thenReturn(currentConfig);
- executor.setRule(rule);
- CreateBroadcastTableRuleStatement sqlStatement = new
CreateBroadcastTableRuleStatement(false, Collections.singleton("t_address"));
- assertThrows(EmptyStorageUnitException.class, () ->
executor.checkBeforeUpdate(sqlStatement));
+ assertThrows(EmptyStorageUnitException.class, () -> new
DistSQLUpdateExecuteEngine(sqlStatement, "foo_db", mockContextManager(database,
rule)).executeUpdate());
}
@Test
- void assertCheckSQLStatementWithDuplicateBroadcastRule() {
- executor.setDatabase(mockShardingSphereDatabase());
+ void assertExecuteUpdateWithDuplicateBroadcastTables() {
+ CreateBroadcastTableRuleStatement sqlStatement = new
CreateBroadcastTableRuleStatement(false, Collections.singleton("foo_tbl"));
+ ShardingSphereDatabase database = mock(ShardingSphereDatabase.class,
RETURNS_DEEP_STUBS);
BroadcastRule rule = mock(BroadcastRule.class);
- when(rule.getTables()).thenReturn(Collections.singleton("t_address"));
- executor.setRule(rule);
- CreateBroadcastTableRuleStatement sqlStatement = new
CreateBroadcastTableRuleStatement(false, Collections.singleton("t_address"));
- assertThrows(DuplicateRuleException.class, () ->
executor.checkBeforeUpdate(sqlStatement));
+ when(rule.getTables()).thenReturn(Collections.singleton("foo_tbl"));
+ assertThrows(DuplicateRuleException.class, () -> new
DistSQLUpdateExecuteEngine(sqlStatement, "foo_db", mockContextManager(database,
rule)).executeUpdate());
}
@Test
- void assertBuildToBeCreatedRuleConfiguration() {
- BroadcastRuleConfiguration currentConfig = new
BroadcastRuleConfiguration(new LinkedList<>());
- executor.setDatabase(mockShardingSphereDatabase());
+ void assertExecuteUpdateWithIfNotExists() throws SQLException {
+ CreateBroadcastTableRuleStatement sqlStatement = new
CreateBroadcastTableRuleStatement(true, new
ArrayList<>(Arrays.asList("foo_tbl", "bar_tbl")));
+ ShardingSphereDatabase database = mock(ShardingSphereDatabase.class,
RETURNS_DEEP_STUBS);
BroadcastRule rule = mock(BroadcastRule.class);
- when(rule.getConfiguration()).thenReturn(currentConfig);
- executor.setRule(rule);
- CreateBroadcastTableRuleStatement sqlStatement = new
CreateBroadcastTableRuleStatement(false, Collections.singleton("t_address"));
- executor.checkBeforeUpdate(sqlStatement);
- BroadcastRuleConfiguration toBeCreatedRuleConfig =
executor.buildToBeCreatedRuleConfiguration(sqlStatement);
- assertThat(toBeCreatedRuleConfig.getTables().size(), is(1));
- assertThat(toBeCreatedRuleConfig.getTables().iterator().next(),
is("t_address"));
+ when(rule.getTables()).thenReturn(Collections.singleton("foo_tbl"));
+ ContextManager contextManager = mockContextManager(database, rule);
+ new DistSQLUpdateExecuteEngine(sqlStatement, "foo_db",
contextManager).executeUpdate();
+ MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
+
verify(metaDataManagerPersistService).alterRuleConfiguration(eq("foo_db"),
+ ArgumentMatchers.<BroadcastRuleConfiguration>argThat(x ->
x.getTables().equals(new HashSet<>(Arrays.asList("foo_tbl", "bar_tbl")))));
}
- private ShardingSphereDatabase mockShardingSphereDatabase() {
+ @Test
+ void assertExecuteUpdateWithoutIfNotExists() throws SQLException {
+ CreateBroadcastTableRuleStatement sqlStatement = new
CreateBroadcastTableRuleStatement(false, Collections.singleton("bar_tbl"));
+ ShardingSphereDatabase database = mock(ShardingSphereDatabase.class,
RETURNS_DEEP_STUBS);
+ BroadcastRule rule = mock(BroadcastRule.class);
+ when(rule.getTables()).thenReturn(Collections.singleton("foo_tbl"));
+ ContextManager contextManager = mockContextManager(database, rule);
+ new DistSQLUpdateExecuteEngine(sqlStatement, "foo_db",
contextManager).executeUpdate();
+ MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
+
verify(metaDataManagerPersistService).alterRuleConfiguration(eq("foo_db"),
+ ArgumentMatchers.<BroadcastRuleConfiguration>argThat(x ->
x.getTables().equals(new HashSet<>(Arrays.asList("foo_tbl", "bar_tbl")))));
+ }
+
+ @Test
+ void assertExecuteUpdateWithoutExistedRule() throws SQLException {
+ CreateBroadcastTableRuleStatement sqlStatement = new
CreateBroadcastTableRuleStatement(false, new
ArrayList<>(Arrays.asList("foo_tbl", "bar_tbl")));
ShardingSphereDatabase database = mock(ShardingSphereDatabase.class,
RETURNS_DEEP_STUBS);
-
when(database.getResourceMetaData().getStorageUnits()).thenReturn(Collections.singletonMap("ds_0",
mock(StorageUnit.class)));
- return database;
+ ContextManager contextManager = mockContextManager(database, null);
+ new DistSQLUpdateExecuteEngine(sqlStatement, "foo_db",
contextManager).executeUpdate();
+ MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
+
verify(metaDataManagerPersistService).alterRuleConfiguration(eq("foo_db"),
+ ArgumentMatchers.<BroadcastRuleConfiguration>argThat(x ->
x.getTables().equals(new HashSet<>(Arrays.asList("foo_tbl", "bar_tbl")))));
}
}
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 3446ca49999..85f18249981 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
@@ -52,16 +52,16 @@ class SetDefaultSingleTableStorageUnitExecutorTest {
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));
+ DistSQLUpdateExecuteEngine engine = new DistSQLUpdateExecuteEngine(new
SetDefaultSingleTableStorageUnitStatement("foo_ds"), "foo_db",
mockContextManager(database, rule));
assertThrows(MissingRequiredStorageUnitsException.class,
engine::executeUpdate);
}
@Test
void assertExecuteUpdateWithoutDefaultStorageUnit() throws SQLException {
+ ShardingSphereDatabase database = mock(ShardingSphereDatabase.class,
RETURNS_DEEP_STUBS);
SingleRule rule = mock(SingleRule.class);
when(rule.getConfiguration()).thenReturn(new
SingleRuleConfiguration(Collections.emptyList(), "foo_ds"));
- ShardingSphereDatabase database = mock(ShardingSphereDatabase.class,
RETURNS_DEEP_STUBS);
- ContextManager contextManager = mockContextManager(rule, database);
+ ContextManager contextManager = mockContextManager(database, rule);
new DistSQLUpdateExecuteEngine(new
SetDefaultSingleTableStorageUnitStatement(null), "foo_db",
contextManager).executeUpdate();
MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
verify(metaDataManagerPersistService)
@@ -71,20 +71,20 @@ class SetDefaultSingleTableStorageUnitExecutorTest {
@Test
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);
+ 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());
+ ContextManager contextManager = mockContextManager(database, rule);
new DistSQLUpdateExecuteEngine(new
SetDefaultSingleTableStorageUnitStatement("bar_ds"), "foo_db",
contextManager).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"))));
}
- private ContextManager mockContextManager(final SingleRule rule, final
ShardingSphereDatabase database) {
+ private ContextManager mockContextManager(final ShardingSphereDatabase
database, final SingleRule rule) {
ContextManager result = mock(ContextManager.class, RETURNS_DEEP_STUBS);
when(database.getName()).thenReturn("foo_db");
when(database.getRuleMetaData()).thenReturn(new
RuleMetaData(Collections.singleton(rule)));
