This is an automated email from the ASF dual-hosted git repository.
menghaoran 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 e6da3aab3dd Refactor ResourceSwitchManagerTest (#37666)
e6da3aab3dd is described below
commit e6da3aab3dd5695e1705f90a45ab185cad7e896f
Author: Haoran Meng <[email protected]>
AuthorDate: Wed Jan 7 07:43:35 2026 +0800
Refactor ResourceSwitchManagerTest (#37666)
---
.../resource/ResourceSwitchManagerTest.java | 175 +++++++++++++++++++++
1 file changed, 175 insertions(+)
diff --git
a/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/manager/resource/ResourceSwitchManagerTest.java
b/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/manager/resource/ResourceSwitchManagerTest.java
index 17989e96f39..66f4b881c09 100644
---
a/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/manager/resource/ResourceSwitchManagerTest.java
+++
b/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/manager/resource/ResourceSwitchManagerTest.java
@@ -25,16 +25,23 @@ import
org.apache.shardingsphere.infra.metadata.database.resource.unit.StorageUn
import
org.apache.shardingsphere.test.infra.framework.extension.mock.AutoMockExtension;
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.MockedStatic;
import javax.sql.DataSource;
import java.util.Arrays;
+import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Map;
+import java.util.stream.Stream;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.aMapWithSize;
+import static org.hamcrest.Matchers.containsInAnyOrder;
import static org.hamcrest.Matchers.hasEntry;
import static org.hamcrest.Matchers.hasKey;
import static org.hamcrest.Matchers.is;
@@ -122,6 +129,174 @@ class ResourceSwitchManagerTest {
assertThat(resourceMetaData.getStorageUnits(), hasKey("drop"));
}
+ @ParameterizedTest(name = "Register storage units with {0} existing units
and {1} new units")
+ @MethodSource("provideRegisterStorageUnitArguments")
+ void assertSwitchByRegisterStorageUnitWithVariousScenarios(final int
existingUnitsCount, final int newUnitsCount) {
+ ResourceMetaData resourceMetaData =
createResourceMetaDataWithMultipleUnits(existingUnitsCount);
+ Map<String, DataSourcePoolProperties> toBeRegistered =
createDataSourcePoolPropertiesMap(newUnitsCount, "new_");
+ DataSource newDataSource = mock(DataSource.class);
+ try (MockedStatic<DataSourcePoolCreator> mocked =
mockStatic(DataSourcePoolCreator.class)) {
+ mocked.when(() ->
DataSourcePoolCreator.create(any(DataSourcePoolProperties.class))).thenReturn(newDataSource);
+ SwitchingResource actual =
resourceSwitchManager.switchByRegisterStorageUnit(resourceMetaData,
toBeRegistered);
+ assertThat(actual.getNewDataSources().size(), is(newUnitsCount));
+ assertThat(actual.getNewDataSources().size(), is(newUnitsCount));
+ for (int i = 0; i < newUnitsCount; i++) {
+ assertThat(actual.getNewDataSources(), hasKey(new
StorageNode("new_" + i)));
+ }
+ }
+ }
+
+ @ParameterizedTest(name = "Alter storage units with {0} total units and
alter {1} units")
+ @MethodSource("provideAlterStorageUnitArguments")
+ void assertSwitchByAlterStorageUnitWithVariousScenarios(final int
totalUnits, final int alterUnitsCount) {
+ ResourceMetaData resourceMetaData =
createResourceMetaDataWithMultipleUnits(totalUnits);
+ Map<String, DataSourcePoolProperties> toBeAltered =
createDataSourcePoolPropertiesMap(alterUnitsCount, "");
+ DataSource newDataSource = mock(DataSource.class);
+ try (MockedStatic<DataSourcePoolCreator> mocked =
mockStatic(DataSourcePoolCreator.class)) {
+ mocked.when(() ->
DataSourcePoolCreator.create(any(DataSourcePoolProperties.class))).thenReturn(newDataSource);
+ SwitchingResource actual =
resourceSwitchManager.switchByAlterStorageUnit(resourceMetaData, toBeAltered);
+ assertThat(actual.getNewDataSources().size(), is(totalUnits));
+ assertThat(actual.getStaleDataSources().size(), is(totalUnits));
+
assertTrue(actual.getStaleStorageUnitNames().containsAll(toBeAltered.keySet()));
+ }
+ }
+
+ @ParameterizedTest(name = "Unregister storage units with {0} total units
and remove {1} units")
+ @MethodSource("provideUnregisterStorageUnitArguments")
+ void assertSwitchByUnregisterStorageUnitWithVariousScenarios(final int
totalUnits, final int removeUnitsCount) {
+ ResourceMetaData resourceMetaData =
createResourceMetaDataWithMultipleUnits(totalUnits);
+ Collection<String> toBeRemoved =
+ Arrays.asList(String.valueOf(0), String.valueOf(1),
String.valueOf(2), String.valueOf(3), String.valueOf(4)).subList(0,
Math.min(removeUnitsCount, totalUnits));
+ SwitchingResource actual =
resourceSwitchManager.switchByUnregisterStorageUnit(resourceMetaData,
toBeRemoved);
+ assertThat(actual.getStaleStorageUnitNames(), is(toBeRemoved));
+ assertThat(actual.getMergedDataSourcePoolPropertiesMap().size(),
is(totalUnits - toBeRemoved.size()));
+ for (String each : toBeRemoved) {
+ assertThat(actual.getMergedDataSourcePoolPropertiesMap(),
not(hasKey(each)));
+ }
+ }
+
+ @Test
+ void assertSwitchByRegisterStorageUnitWithEmptyInput() {
+ ResourceMetaData resourceMetaData =
createResourceMetaDataWithSingleUnit("ds_existing");
+ Map<String, DataSourcePoolProperties> toBeRegistered =
Collections.emptyMap();
+ SwitchingResource actual =
resourceSwitchManager.switchByRegisterStorageUnit(resourceMetaData,
toBeRegistered);
+ assertThat(actual.getNewDataSources(), aMapWithSize(0));
+ assertThat(actual.getStaleDataSources(), aMapWithSize(0));
+ assertThat(actual.getStaleStorageUnitNames().isEmpty(), is(true));
+ assertThat(actual.getMergedDataSourcePoolPropertiesMap(),
hasKey("ds_existing"));
+ }
+
+ @Test
+ void assertSwitchByAlterStorageUnitWithEmptyInput() {
+ ResourceMetaData resourceMetaData =
createResourceMetaDataWithSingleUnit("ds_existing");
+ Map<String, DataSourcePoolProperties> toBeAltered =
Collections.emptyMap();
+ DataSource newDataSource = mock(DataSource.class);
+ try (MockedStatic<DataSourcePoolCreator> mocked =
mockStatic(DataSourcePoolCreator.class)) {
+ mocked.when(() ->
DataSourcePoolCreator.create(any(DataSourcePoolProperties.class))).thenReturn(newDataSource);
+ SwitchingResource actual =
resourceSwitchManager.switchByAlterStorageUnit(resourceMetaData, toBeAltered);
+ assertThat(actual.getNewDataSources().size(), is(1));
+ assertThat(actual.getStaleDataSources().size(), is(1));
+ assertThat(actual.getStaleStorageUnitNames().isEmpty(), is(false));
+ assertThat(actual.getMergedDataSourcePoolPropertiesMap(),
hasKey("ds_existing"));
+ }
+ }
+
+ @Test
+ void assertSwitchByUnregisterStorageUnitWithEmptyInput() {
+ ResourceMetaData resourceMetaData =
createResourceMetaDataWithSingleUnit("ds_existing");
+ SwitchingResource actual =
resourceSwitchManager.switchByUnregisterStorageUnit(resourceMetaData,
Collections.emptySet());
+ assertThat(actual.getStaleDataSources(), aMapWithSize(0));
+ assertThat(actual.getStaleStorageUnitNames().isEmpty(), is(true));
+ assertThat(actual.getMergedDataSourcePoolPropertiesMap(),
hasKey("ds_existing"));
+ }
+
+ @Test
+ void assertCreateByUnregisterStorageUnitWithEmptyInput() {
+ ResourceMetaData resourceMetaData =
createResourceMetaDataWithSingleUnit("ds_existing");
+ SwitchingResource actual =
resourceSwitchManager.createByUnregisterStorageUnit(resourceMetaData,
Collections.emptySet());
+ assertThat(actual.getStaleDataSources(), aMapWithSize(0));
+ assertThat(actual.getStaleStorageUnitNames().isEmpty(), is(true));
+ assertThat(actual.getMergedDataSourcePoolPropertiesMap(),
hasKey("ds_existing"));
+ }
+
+ @Test
+ void assertSwitchByRegisterStorageUnitWithDuplicateDataSourceName() {
+ ResourceMetaData resourceMetaData =
createResourceMetaDataWithMultipleUnits(3);
+ Map<String, DataSourcePoolProperties> toBeRegistered = new
LinkedHashMap<>(2, 1F);
+ toBeRegistered.put("0", createDataSourcePoolProperties());
+ toBeRegistered.put("new_0", createDataSourcePoolProperties());
+ DataSource newDataSource = mock(DataSource.class);
+ try (MockedStatic<DataSourcePoolCreator> mocked =
mockStatic(DataSourcePoolCreator.class)) {
+ mocked.when(() ->
DataSourcePoolCreator.create(any(DataSourcePoolProperties.class))).thenReturn(newDataSource);
+ SwitchingResource actual =
resourceSwitchManager.switchByRegisterStorageUnit(resourceMetaData,
toBeRegistered);
+ assertThat(actual.getNewDataSources().size(), is(1));
+ assertThat(actual.getNewDataSources(), hasKey(new
StorageNode("new_0")));
+ }
+ }
+
+ @Test
+ void assertSwitchByAlterStorageUnitWithMultipleUnits() {
+ ResourceMetaData resourceMetaData =
createResourceMetaDataWithMultipleUnits(5);
+ Map<String, DataSourcePoolProperties> toBeAltered = new
LinkedHashMap<>(2, 1F);
+ toBeAltered.put("1", createDataSourcePoolProperties());
+ toBeAltered.put("3", createDataSourcePoolProperties());
+ DataSource newDataSource = mock(DataSource.class);
+ try (MockedStatic<DataSourcePoolCreator> mocked =
mockStatic(DataSourcePoolCreator.class)) {
+ mocked.when(() ->
DataSourcePoolCreator.create(any(DataSourcePoolProperties.class))).thenReturn(newDataSource);
+ SwitchingResource actual =
resourceSwitchManager.switchByAlterStorageUnit(resourceMetaData, toBeAltered);
+ assertThat(actual.getNewDataSources().size(), is(5));
+ assertThat(actual.getStaleDataSources().size(), is(5));
+ assertThat(actual.getStaleStorageUnitNames(),
containsInAnyOrder("0", "1", "2", "3", "4"));
+ }
+ }
+
+ private static Stream<Arguments> provideRegisterStorageUnitArguments() {
+ return Stream.of(
+ Arguments.of(0, 1),
+ Arguments.of(1, 1),
+ Arguments.of(1, 2),
+ Arguments.of(3, 1),
+ Arguments.of(3, 3));
+ }
+
+ private static Stream<Arguments> provideAlterStorageUnitArguments() {
+ return Stream.of(
+ Arguments.of(1, 1),
+ Arguments.of(3, 1),
+ Arguments.of(3, 2),
+ Arguments.of(5, 3));
+ }
+
+ private static Stream<Arguments> provideUnregisterStorageUnitArguments() {
+ return Stream.of(
+ Arguments.of(1, 0),
+ Arguments.of(1, 1),
+ Arguments.of(3, 1),
+ Arguments.of(3, 2),
+ Arguments.of(5, 5));
+ }
+
+ private ResourceMetaData createResourceMetaDataWithMultipleUnits(final int
count) {
+ Map<StorageNode, DataSource> dataSources = new LinkedHashMap<>(count,
1F);
+ Map<String, StorageUnit> storageUnits = new LinkedHashMap<>(count, 1F);
+ for (int i = 0; i < count; i++) {
+ String name = String.valueOf(i);
+ StorageNode storageNode = new StorageNode(name);
+ DataSource dataSource = mock(DataSource.class);
+ dataSources.put(storageNode, dataSource);
+ storageUnits.put(name, new StorageUnit(storageNode,
createDataSourcePoolProperties(), dataSource));
+ }
+ return new ResourceMetaData(dataSources, storageUnits);
+ }
+
+ private Map<String, DataSourcePoolProperties>
createDataSourcePoolPropertiesMap(final int count, final String prefix) {
+ Map<String, DataSourcePoolProperties> result = new
LinkedHashMap<>(count, 1F);
+ for (int i = 0; i < count; i++) {
+ result.put(prefix + i, createDataSourcePoolProperties());
+ }
+ return result;
+ }
+
private ResourceMetaData createResourceMetaDataWithSingleUnit(final String
name) {
StorageNode storageNode = new StorageNode(name);
DataSource dataSource = mock(DataSource.class);
