You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by zh...@apache.org on 2026/02/19 10:33:58 UTC

(shardingsphere) branch master updated: Add more test cases on UnloadSingleTableExecutorTest (#38100)

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 4f0649a2e7d Add more test cases on UnloadSingleTableExecutorTest (#38100)
4f0649a2e7d is described below

commit 4f0649a2e7dec361f0dd9c00115273e29b9a9d05
Author: Liang Zhang <zh...@apache.org>
AuthorDate: Thu Feb 19 18:33:51 2026 +0800

    Add more test cases on UnloadSingleTableExecutorTest (#38100)
    
    * Add more test cases on UnloadSingleTableExecutorTest
    
    * Add more test cases on UnloadSingleTableExecutorTest
---
 .../update/UnloadSingleTableExecutorTest.java      | 202 +++++++++++++++++++++
 1 file changed, 202 insertions(+)

diff --git a/kernel/single/distsql/handler/src/test/java/org/apache/shardingsphere/single/distsql/handler/update/UnloadSingleTableExecutorTest.java b/kernel/single/distsql/handler/src/test/java/org/apache/shardingsphere/single/distsql/handler/update/UnloadSingleTableExecutorTest.java
new file mode 100644
index 00000000000..4c08226be4f
--- /dev/null
+++ b/kernel/single/distsql/handler/src/test/java/org/apache/shardingsphere/single/distsql/handler/update/UnloadSingleTableExecutorTest.java
@@ -0,0 +1,202 @@
+/*
+ * 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.single.distsql.handler.update;
+
+import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
+import org.apache.shardingsphere.database.exception.core.exception.syntax.table.NoSuchTableException;
+import org.apache.shardingsphere.distsql.handler.engine.update.rdl.rule.spi.database.DatabaseRuleDefinitionExecutor;
+import org.apache.shardingsphere.infra.datanode.DataNode;
+import org.apache.shardingsphere.infra.exception.kernel.metadata.rule.MissingRequiredRuleException;
+import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
+import org.apache.shardingsphere.infra.metadata.database.rule.RuleMetaData;
+import org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereSchema;
+import org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereTable;
+import org.apache.shardingsphere.infra.rule.attribute.RuleAttributes;
+import org.apache.shardingsphere.infra.rule.attribute.datanode.DataNodeRuleAttribute;
+import org.apache.shardingsphere.infra.rule.attribute.table.TableMapperRuleAttribute;
+import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
+import org.apache.shardingsphere.single.config.SingleRuleConfiguration;
+import org.apache.shardingsphere.single.distsql.statement.rdl.UnloadSingleTableStatement;
+import org.apache.shardingsphere.single.exception.SingleTableNotFoundException;
+import org.apache.shardingsphere.single.rule.SingleRule;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+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.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
+class UnloadSingleTableExecutorTest {
+    
+    private final DatabaseType databaseType = TypedSPILoader.getService(DatabaseType.class, "FIXTURE");
+    
+    private final UnloadSingleTableExecutor executor = (UnloadSingleTableExecutor) TypedSPILoader.getService(DatabaseRuleDefinitionExecutor.class, UnloadSingleTableStatement.class);
+    
+    @Mock
+    private ShardingSphereDatabase database;
+    
+    @Mock
+    private SingleRule rule;
+    
+    @Mock
+    private TableMapperRuleAttribute tableMapperRuleAttribute;
+    
+    @Mock
+    private DataNodeRuleAttribute dataNodeRuleAttribute;
+    
+    @BeforeEach
+    void setUp() {
+        executor.setDatabase(database);
+        executor.setRule(rule);
+        when(database.getName()).thenReturn("foo_db");
+        when(database.getProtocolType()).thenReturn(databaseType);
+        when(database.getRuleMetaData()).thenReturn(new RuleMetaData(Collections.singleton(rule)));
+        when(rule.getAttributes()).thenReturn(new RuleAttributes(tableMapperRuleAttribute, dataNodeRuleAttribute));
+    }
+    
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("assertCheckBeforeUpdateWithFailureArguments")
+    void assertCheckBeforeUpdateWithFailure(final String name, final Collection<String> allTables, final Collection<String> singleTables, final Collection<DataNode> dataNodes,
+                                            final Collection<String> configuredTables, final Class<? extends RuntimeException> expectedException) {
+        Map<String, Collection<DataNode>> tableDataNodes = new HashMap<>(1, 1F);
+        tableDataNodes.put("foo_tbl", dataNodes);
+        prepareCheckBeforeUpdateContext(allTables, singleTables, tableDataNodes, configuredTables);
+        assertThrows(expectedException, () -> executor.checkBeforeUpdate(new UnloadSingleTableStatement(false, Collections.singletonList("foo_tbl"))));
+    }
+    
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("assertCheckBeforeUpdateWithSuccessArguments")
+    void assertCheckBeforeUpdate(final String name, final UnloadSingleTableStatement sqlStatement, final Collection<String> allTables,
+                                 final Collection<String> singleTables, final Map<String, Collection<DataNode>> tableDataNodes, final Collection<String> configuredTables) {
+        prepareCheckBeforeUpdateContext(allTables, singleTables, tableDataNodes, configuredTables);
+        assertDoesNotThrow(() -> executor.checkBeforeUpdate(sqlStatement));
+    }
+    
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("assertBuildToBeAlteredRuleConfigurationArguments")
+    void assertBuildToBeAlteredRuleConfiguration(final String name, final Collection<String> currentTables,
+                                                 final UnloadSingleTableStatement sqlStatement, final Collection<String> expectedTables) {
+        when(rule.getConfiguration()).thenReturn(new SingleRuleConfiguration(new LinkedList<>(currentTables), null));
+        SingleRuleConfiguration actual = executor.buildToBeAlteredRuleConfiguration(sqlStatement);
+        assertThat(new HashSet<>(actual.getTables()), is(new HashSet<>(expectedTables)));
+    }
+    
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("assertBuildToBeDroppedRuleConfigurationArguments")
+    void assertBuildToBeDroppedRuleConfiguration(final String name, final Collection<String> currentTables, final Collection<String> toBeAlteredTables,
+                                                 final boolean expectedNull, final Collection<String> expectedTables) {
+        when(rule.getConfiguration()).thenReturn(new SingleRuleConfiguration(new LinkedList<>(currentTables), null));
+        SingleRuleConfiguration toBeAltered = new SingleRuleConfiguration(new LinkedList<>(toBeAlteredTables), null);
+        SingleRuleConfiguration actual = executor.buildToBeDroppedRuleConfiguration(toBeAltered);
+        if (expectedNull) {
+            assertNull(actual);
+        } else {
+            assertNotNull(actual);
+            assertThat(new HashSet<>(actual.getTables()), is(new HashSet<>(expectedTables)));
+        }
+    }
+    
+    @Test
+    void assertGetRuleClass() {
+        assertThat(executor.getRuleClass(), is(SingleRule.class));
+    }
+    
+    private void prepareCheckBeforeUpdateContext(final Collection<String> allTables, final Collection<String> singleTables,
+                                                 final Map<String, Collection<DataNode>> tableDataNodes, final Collection<String> configuredTables) {
+        ShardingSphereSchema schema = mock(ShardingSphereSchema.class);
+        when(schema.getAllTables()).thenReturn(
+                allTables.stream().map(each -> new ShardingSphereTable(each, Collections.emptyList(), Collections.emptyList(), Collections.emptyList())).collect(Collectors.toList()));
+        when(database.getSchema("foo_db")).thenReturn(schema);
+        when(tableMapperRuleAttribute.getLogicTableNames()).thenReturn(singleTables);
+        when(dataNodeRuleAttribute.getDataNodesByTableName(anyString())).thenAnswer(invocation -> tableDataNodes.getOrDefault(invocation.getArgument(0), Collections.emptyList()));
+        when(rule.getConfiguration()).thenReturn(new SingleRuleConfiguration(new LinkedList<>(configuredTables), null));
+    }
+    
+    private static Stream<Arguments> assertCheckBeforeUpdateWithFailureArguments() {
+        return Stream.of(
+                Arguments.of("missing table throws NoSuchTableException", Collections.emptyList(), Collections.singleton("foo_tbl"), Collections.singleton(new DataNode("foo_ds.foo_tbl")),
+                        Collections.singleton("foo_ds.foo_tbl"), NoSuchTableException.class),
+                Arguments.of("non single table throws SingleTableNotFoundException", Collections.singleton("foo_tbl"), Collections.emptyList(), Collections.singleton(new DataNode("foo_ds.foo_tbl")),
+                        Collections.singleton("foo_ds.foo_tbl"), SingleTableNotFoundException.class),
+                Arguments.of("missing data node throws MissingRequiredRuleException", Collections.singleton("foo_tbl"), Collections.singleton("foo_tbl"), Collections.emptyList(),
+                        Collections.singleton("foo_ds.foo_tbl"), MissingRequiredRuleException.class),
+                Arguments.of("missing rule config throws MissingRequiredRuleException", Collections.singleton("foo_tbl"), Collections.singleton("foo_tbl"),
+                        Collections.singleton(new DataNode("foo_ds.foo_tbl")),
+                        Collections.emptyList(), MissingRequiredRuleException.class));
+    }
+    
+    private static Stream<Arguments> assertCheckBeforeUpdateWithSuccessArguments() {
+        Map<String, Collection<DataNode>> singleTableNodes = new HashMap<>(1, 1F);
+        singleTableNodes.put("foo_tbl", Collections.singleton(new DataNode("foo_ds.foo_tbl")));
+        Map<String, Collection<DataNode>> multipleTableNodes = new HashMap<>(2, 1F);
+        multipleTableNodes.put("foo_tbl", Collections.singleton(new DataNode("foo_ds.foo_tbl")));
+        multipleTableNodes.put("bar_tbl", Collections.singleton(new DataNode("foo_ds.foo_schema.bar_tbl")));
+        return Stream.of(
+                Arguments.of("unload all tables bypasses table checks", new UnloadSingleTableStatement(true, Collections.emptyList()),
+                        Collections.emptyList(), Collections.emptyList(), Collections.emptyMap(), Collections.emptyList()),
+                Arguments.of("valid single table passes checks", new UnloadSingleTableStatement(false, Collections.singletonList("foo_tbl")),
+                        Collections.singleton("foo_tbl"), Collections.singleton("foo_tbl"), singleTableNodes, Collections.singleton("foo_ds.foo_tbl")),
+                Arguments.of("valid multiple tables pass checks", new UnloadSingleTableStatement(false, Arrays.asList("foo_tbl", "bar_tbl")),
+                        Arrays.asList("foo_tbl", "bar_tbl"), Arrays.asList("foo_tbl", "bar_tbl"), multipleTableNodes, Arrays.asList("foo_ds.foo_tbl", "foo_ds.bar_tbl")));
+    }
+    
+    private static Stream<Arguments> assertBuildToBeAlteredRuleConfigurationArguments() {
+        return Stream.of(
+                Arguments.of("unload all tables keeps altered config empty", Arrays.asList("foo_ds.foo_tbl", "foo_ds.bar_tbl"), new UnloadSingleTableStatement(true, Collections.emptyList()),
+                        Collections.emptyList()),
+                Arguments.of("unload one table removes matching two-segment node", Arrays.asList("foo_ds.foo_tbl", "foo_ds.bar_tbl"),
+                        new UnloadSingleTableStatement(false, Collections.singletonList("foo_tbl")), Collections.singleton("foo_ds.bar_tbl")),
+                Arguments.of("unload one table removes matching three-segment node", Arrays.asList("foo_ds.foo_schema.bar_tbl", "foo_ds.foo_tbl"),
+                        new UnloadSingleTableStatement(false, Collections.singletonList("bar_tbl")), Collections.singleton("foo_ds.foo_tbl")));
+    }
+    
+    private static Stream<Arguments> assertBuildToBeDroppedRuleConfigurationArguments() {
+        return Stream.of(
+                Arguments.of("empty altered config drops current rule config", Arrays.asList("foo_ds.foo_tbl", "foo_ds.bar_tbl"), Collections.emptyList(), false,
+                        Arrays.asList("foo_ds.foo_tbl", "foo_ds.bar_tbl")),
+                Arguments.of("non-empty altered config does not drop rule", Collections.singleton("foo_ds.foo_tbl"), Collections.singleton("foo_ds.foo_tbl"), true, Collections.emptyList()),
+                Arguments.of("multi-table altered config does not drop rule", Arrays.asList("foo_ds.foo_tbl", "foo_ds.bar_tbl"), Arrays.asList("foo_ds.foo_tbl", "foo_ds.bar_tbl"), true,
+                        Collections.emptyList()));
+    }
+}