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 47587318bbe Add more test cases on MetaDataContextsFactoryTest (#37213)
47587318bbe is described below
commit 47587318bbe4fe1ac6bed9e988eb0c3f625f6956
Author: Liang Zhang <[email protected]>
AuthorDate: Fri Nov 28 18:10:02 2025 +0800
Add more test cases on MetaDataContextsFactoryTest (#37213)
* Add more test cases on MetaDataContextsFactoryTest
* Add more test cases on MetaDataContextsFactoryTest
---
.../factory/MetaDataContextsFactoryTest.java | 172 ++++++++++++++++++++-
1 file changed, 164 insertions(+), 8 deletions(-)
diff --git
a/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/factory/MetaDataContextsFactoryTest.java
b/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/factory/MetaDataContextsFactoryTest.java
index 7d4affe4823..78fb17ab4ed 100644
---
a/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/factory/MetaDataContextsFactoryTest.java
+++
b/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/factory/MetaDataContextsFactoryTest.java
@@ -18,22 +18,42 @@
package org.apache.shardingsphere.mode.metadata.factory;
import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
+import
org.apache.shardingsphere.database.connector.core.type.DatabaseTypeFactory;
import org.apache.shardingsphere.infra.config.database.DatabaseConfiguration;
import
org.apache.shardingsphere.infra.config.database.impl.DataSourceProvidedDatabaseConfiguration;
import org.apache.shardingsphere.infra.config.props.ConfigurationProperties;
+import org.apache.shardingsphere.infra.config.props.ConfigurationPropertyKey;
+import org.apache.shardingsphere.infra.database.DatabaseTypeEngine;
+import
org.apache.shardingsphere.infra.datasource.pool.props.domain.DataSourcePoolProperties;
import org.apache.shardingsphere.infra.instance.ComputeNodeInstanceContext;
import
org.apache.shardingsphere.infra.instance.metadata.jdbc.JDBCInstanceMetaData;
import
org.apache.shardingsphere.infra.instance.metadata.proxy.ProxyInstanceMetaData;
+import org.apache.shardingsphere.infra.metadata.ShardingSphereMetaData;
import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
+import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabaseFactory;
import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabasesFactory;
+import
org.apache.shardingsphere.infra.metadata.database.resource.ResourceMetaData;
+import
org.apache.shardingsphere.infra.metadata.database.resource.node.StorageNode;
+import
org.apache.shardingsphere.infra.metadata.database.resource.unit.StorageUnit;
+import
org.apache.shardingsphere.infra.metadata.database.resource.unit.StorageUnitNodeMapCreator;
+import org.apache.shardingsphere.infra.metadata.database.rule.RuleMetaData;
+import
org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereColumn;
+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.metadata.statistics.ShardingSphereStatistics;
+import
org.apache.shardingsphere.infra.metadata.statistics.builder.ShardingSphereStatisticsFactory;
import org.apache.shardingsphere.infra.rule.builder.global.GlobalRulesBuilder;
import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
+import org.apache.shardingsphere.infra.util.props.PropertiesBuilder;
+import org.apache.shardingsphere.infra.util.props.PropertiesBuilder.Property;
import
org.apache.shardingsphere.mode.manager.builder.ContextManagerBuilderParameter;
import org.apache.shardingsphere.mode.metadata.MetaDataContexts;
+import
org.apache.shardingsphere.mode.metadata.manager.resource.SwitchingResource;
import org.apache.shardingsphere.mode.metadata.persist.MetaDataPersistFacade;
import org.apache.shardingsphere.mode.spi.repository.PersistRepository;
import org.apache.shardingsphere.test.infra.fixture.jdbc.MockedDataSource;
import org.apache.shardingsphere.test.infra.fixture.rule.MockedRule;
+import
org.apache.shardingsphere.test.infra.fixture.rule.MockedRuleConfiguration;
import
org.apache.shardingsphere.test.infra.framework.extension.mock.AutoMockExtension;
import
org.apache.shardingsphere.test.infra.framework.extension.mock.StaticMockSettings;
import org.junit.jupiter.api.BeforeEach;
@@ -44,23 +64,31 @@ import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
+import javax.sql.DataSource;
import java.sql.SQLException;
+import java.util.Arrays;
+import java.util.Collection;
import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
import java.util.Properties;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.isA;
+import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.anyCollection;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.any;
-import static org.mockito.Mockito.anyCollection;
import static org.mockito.Mockito.anyMap;
+import static org.mockito.Mockito.anyString;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@ExtendWith(AutoMockExtension.class)
-@StaticMockSettings({ShardingSphereDatabasesFactory.class,
GlobalRulesBuilder.class})
+@StaticMockSettings({ShardingSphereDatabasesFactory.class,
GlobalRulesBuilder.class, DatabaseTypeEngine.class,
+ ShardingSphereDatabaseFactory.class,
ShardingSphereStatisticsFactory.class, StorageUnitNodeMapCreator.class,
DatabaseTypeFactory.class})
@MockitoSettings(strictness = Strictness.LENIENT)
class MetaDataContextsFactoryTest {
@@ -69,20 +97,29 @@ class MetaDataContextsFactoryTest {
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private MetaDataPersistFacade metaDataPersistFacade;
- @Mock(answer = Answers.RETURNS_DEEP_STUBS)
+ @Mock
private PersistRepository repository;
@BeforeEach
- void setUp() {
- ShardingSphereDatabase database = mock(ShardingSphereDatabase.class,
RETURNS_DEEP_STUBS);
- when(database.getName()).thenReturn("foo_db");
- when(database.getProtocolType()).thenReturn(databaseType);
-
when(database.getRuleMetaData().getRules()).thenReturn(Collections.emptyList());
+ void setUp() throws SQLException {
+ ShardingSphereDatabase database = new ShardingSphereDatabase("foo_db",
+ databaseType, new ResourceMetaData(Collections.emptyMap(),
Collections.emptyMap()), new RuleMetaData(Collections.emptyList()),
Collections.emptyList());
when(ShardingSphereDatabasesFactory.create(anyMap(), anyMap(), any(),
any())).thenReturn(Collections.singleton(database));
+ when(ShardingSphereDatabasesFactory.create(anyMap(),
any(ConfigurationProperties.class),
any(ComputeNodeInstanceContext.class))).thenReturn(Collections.singleton(database));
+ when(ShardingSphereDatabaseFactory.create(anyString(),
any(DatabaseType.class), any(DatabaseConfiguration.class),
any(ConfigurationProperties.class), any(ComputeNodeInstanceContext.class)))
+ .thenAnswer(invocation ->
createDatabaseFromConfiguration(invocation.getArgument(0),
invocation.getArgument(1), invocation.getArgument(2), Collections.emptyList()));
when(GlobalRulesBuilder.buildRules(anyCollection(), anyCollection(),
any(ConfigurationProperties.class))).thenReturn(Collections.singleton(new
MockedRule()));
+
when(DatabaseTypeEngine.getProtocolType(any(DatabaseConfiguration.class),
any(ConfigurationProperties.class))).thenReturn(databaseType);
+ when(DatabaseTypeFactory.get(anyString())).thenReturn(databaseType);
when(metaDataPersistFacade.getRepository()).thenReturn(repository);
}
+ private ShardingSphereDatabase createDatabaseFromConfiguration(final
String databaseName, final DatabaseType protocolType,
+ final
DatabaseConfiguration databaseConfiguration, final
Collection<ShardingSphereSchema> schemas) {
+ return new ShardingSphereDatabase(databaseName, protocolType,
+ new ResourceMetaData(databaseConfiguration.getDataSources(),
databaseConfiguration.getStorageUnits()), new
RuleMetaData(Collections.emptyList()), schemas);
+ }
+
@Test
void assertCreateWithJDBCInstanceMetaData() throws SQLException {
ComputeNodeInstanceContext computeNodeInstanceContext =
mock(ComputeNodeInstanceContext.class, RETURNS_DEEP_STUBS);
@@ -100,6 +137,92 @@ class MetaDataContextsFactoryTest {
assertThat(actual.getMetaData().getAllDatabases().size(), is(1));
}
+ @Test
+ void assertCreateWithoutRegisteredDatabasesUsesLocalFactory() throws
SQLException {
+ MetaDataContexts actual = new
MetaDataContextsFactory(metaDataPersistFacade,
mock()).create(createContextManagerBuilderParameter());
+ assertTrue(actual.getMetaData().containsDatabase("foo_db"));
+
assertThat(actual.getMetaData().getGlobalRuleMetaData().getRules().iterator().next(),
isA(MockedRule.class));
+ }
+
+ @Test
+ void assertCreateBySwitchResourceFiltersStaleResources() throws
SQLException {
+ StorageNode staleNode = new StorageNode("stale_ds");
+ StorageNode activeNode = new StorageNode("active_ds");
+ Map<StorageNode, DataSource> currentStorageNodes = new
LinkedHashMap<>(2, 1F);
+ currentStorageNodes.put(staleNode, new MockedDataSource());
+ currentStorageNodes.put(activeNode, new MockedDataSource());
+ Map<String, StorageUnit> currentStorageUnits = new LinkedHashMap<>(2,
1F);
+ currentStorageUnits.put("stale_ds", createStorageUnit("stale_ds"));
+ currentStorageUnits.put("active_ds", createStorageUnit("active_ds"));
+ ResourceMetaData resourceMetaData = new
ResourceMetaData(currentStorageNodes, currentStorageUnits);
+ ShardingSphereDatabase database = new ShardingSphereDatabase("foo_db",
databaseType, resourceMetaData, new RuleMetaData(Collections.emptyList()),
Collections.emptyList());
+ ShardingSphereMetaData metaData = new
ShardingSphereMetaData(Collections.singleton(database),
+ new ResourceMetaData(Collections.emptyMap(),
Collections.emptyMap()), new RuleMetaData(Collections.emptyList()), new
ConfigurationProperties(new Properties()));
+ MetaDataContexts originalMetaDataContexts = new
MetaDataContexts(metaData, new ShardingSphereStatistics());
+ Map<StorageNode, DataSource> newDataSources =
Collections.singletonMap(new StorageNode("new_ds"), new MockedDataSource());
+ SwitchingResource switchingResource = new
SwitchingResource(newDataSources, Collections.singletonMap(staleNode, new
MockedDataSource()),
+ Collections.singleton("stale_ds"),
createDataSourcePoolPropertiesMap("active_ds", "new_ds"));
+ MetaDataContexts actual = new
MetaDataContextsFactory(metaDataPersistFacade,
mock()).createBySwitchResource("foo_db", false, switchingResource,
originalMetaDataContexts);
+ ResourceMetaData actualResourceMetaData =
actual.getMetaData().getDatabase("foo_db").getResourceMetaData();
+
assertFalse(actualResourceMetaData.getDataSources().containsKey(staleNode));
+
assertTrue(actualResourceMetaData.getDataSources().containsKey(activeNode));
+ assertTrue(actualResourceMetaData.getDataSources().containsKey(new
StorageNode("new_ds")));
+
assertFalse(actualResourceMetaData.getStorageUnits().containsKey("stale_ds"));
+
assertTrue(actualResourceMetaData.getStorageUnits().containsKey("active_ds"));
+
assertTrue(actualResourceMetaData.getStorageUnits().containsKey("new_ds"));
+ }
+
+ @Test
+ void assertCreateBySwitchResourceKeepsExistingNodesWhenNoNewDataSources()
throws SQLException {
+ ResourceMetaData resourceMetaData =
createResourceMetaDataWithSingleUnit();
+ ShardingSphereDatabase database = new ShardingSphereDatabase("foo_db",
databaseType, resourceMetaData, new RuleMetaData(Collections.emptyList()),
Collections.emptyList());
+ ShardingSphereMetaData metaData = new
ShardingSphereMetaData(Collections.singleton(database),
+ new ResourceMetaData(Collections.emptyMap(),
Collections.emptyMap()), new RuleMetaData(Collections.emptyList()), new
ConfigurationProperties(new Properties()));
+ MetaDataContexts originalMetaDataContexts = new
MetaDataContexts(metaData, new ShardingSphereStatistics());
+ SwitchingResource switchingResource = new
SwitchingResource(Collections.emptyMap(), Collections.emptyMap(),
Collections.emptyList(), createDataSourcePoolPropertiesMap("foo_ds"));
+ MetaDataContexts actual = new
MetaDataContextsFactory(metaDataPersistFacade,
mock()).createBySwitchResource("foo_db", false, switchingResource,
originalMetaDataContexts);
+ ResourceMetaData actualResourceMetaData =
actual.getMetaData().getDatabase("foo_db").getResourceMetaData();
+ assertTrue(actualResourceMetaData.getDataSources().containsKey(new
StorageNode("foo_ds")));
+
assertTrue(actualResourceMetaData.getStorageUnits().containsKey("foo_ds"));
+ }
+
+ @Test
+ void
assertCreateByAlterRuleLoadsSchemasFromRepositoryWhenPersistenceDisabled()
throws SQLException {
+ Collection<ShardingSphereSchema> loadedSchemas =
Arrays.asList(createSchemaWithTable("foo_schema", "persisted_table"),
createSchemaWithTable("new_schema", "new_table"));
+
when(metaDataPersistFacade.getDatabaseMetaDataFacade().getSchema().load("foo_db")).thenReturn(loadedSchemas);
+ ShardingSphereSchema originSchema =
createSchemaWithTable("foo_schema", "origin_table");
+ ShardingSphereDatabase database = new ShardingSphereDatabase("foo_db",
databaseType, createResourceMetaDataWithSingleUnit(),
+ new RuleMetaData(Collections.emptyList()),
Collections.singleton(originSchema));
+ ShardingSphereMetaData metaData = new ShardingSphereMetaData(
+ Collections.singleton(database), new
ResourceMetaData(Collections.emptyMap(), Collections.emptyMap()), new
RuleMetaData(Collections.emptyList()),
+ new ConfigurationProperties(PropertiesBuilder.build(new
Property(ConfigurationPropertyKey.PERSIST_SCHEMAS_TO_REPOSITORY_ENABLED.getKey(),
Boolean.FALSE.toString()))));
+ MetaDataContexts originalMetaDataContexts = new
MetaDataContexts(metaData, new ShardingSphereStatistics());
+ MetaDataContexts actual = new
MetaDataContextsFactory(metaDataPersistFacade, mock())
+ .createByAlterRule("foo_db", true, Collections.singleton(new
MockedRuleConfiguration("alter_rule")), originalMetaDataContexts);
+ ShardingSphereSchema mergedSchema = loadedSchemas.stream().filter(each
->
"foo_schema".equals(each.getName())).findFirst().orElseThrow(IllegalStateException::new);
+ assertThat(mergedSchema.getAllTables().size(), is(2));
+ ShardingSphereSchema untouchedSchema =
loadedSchemas.stream().filter(each ->
"new_schema".equals(each.getName())).findFirst().orElseThrow(IllegalStateException::new);
+ assertThat(untouchedSchema.getAllTables().size(), is(1));
+ assertTrue(actual.getMetaData().containsDatabase("foo_db"));
+ }
+
+ @Test
+ void assertCreateByAlterRuleKeepsPersistedSchemasWhenEnabled() throws
SQLException {
+ ShardingSphereDatabase database = new ShardingSphereDatabase(
+ "foo_db", databaseType,
createResourceMetaDataWithSingleUnit(), new
RuleMetaData(Collections.emptyList()), Collections.emptyList());
+ ShardingSphereMetaData metaData = new ShardingSphereMetaData(
+ Collections.singleton(database), new
ResourceMetaData(Collections.emptyMap(), Collections.emptyMap()), new
RuleMetaData(Collections.emptyList()),
+ new ConfigurationProperties(PropertiesBuilder.build(new
Property(ConfigurationPropertyKey.PERSIST_SCHEMAS_TO_REPOSITORY_ENABLED.getKey(),
Boolean.TRUE.toString()))));
+ MetaDataContexts originalMetaDataContexts = new
MetaDataContexts(metaData, new ShardingSphereStatistics());
+ Collection<ShardingSphereSchema> loadedSchemas =
Collections.singleton(createSchemaWithTable("persisted_schema",
"persisted_table"));
+
when(metaDataPersistFacade.getDatabaseMetaDataFacade().getSchema().load("foo_db")).thenReturn(loadedSchemas);
+ MetaDataContexts actual = new
MetaDataContextsFactory(metaDataPersistFacade, mock())
+ .createByAlterRule("foo_db", true, Collections.singleton(new
MockedRuleConfiguration("persist_rule")), originalMetaDataContexts);
+ ShardingSphereSchema persistedSchema = loadedSchemas.iterator().next();
+ assertThat(persistedSchema.getAllTables().size(), is(1));
+ assertTrue(actual.getMetaData().containsDatabase("foo_db"));
+ }
+
@Test
void assertCreateWithProxyInstanceMetaData() throws SQLException {
ComputeNodeInstanceContext computeNodeInstanceContext =
mock(ComputeNodeInstanceContext.class, RETURNS_DEEP_STUBS);
@@ -122,4 +245,37 @@ class MetaDataContextsFactoryTest {
return new ContextManagerBuilderParameter(null,
Collections.singletonMap("foo_db", databaseConfig), Collections.emptyMap(),
Collections.emptyList(), new Properties(),
Collections.emptyList(), null);
}
+
+ private Map<String, DataSourcePoolProperties>
createDataSourcePoolPropertiesMap(final String... storageUnitNames) {
+ Map<String, DataSourcePoolProperties> result = new
LinkedHashMap<>(storageUnitNames.length, 1F);
+ for (String each : storageUnitNames) {
+ Map<String, Object> props = new LinkedHashMap<>(2, 1F);
+ props.put("url", "jdbc:mysql://localhost:3306/" + each);
+ props.put("username", "root");
+ result.put(each, new DataSourcePoolProperties("HikariCP", props));
+ }
+ return result;
+ }
+
+ private StorageUnit createStorageUnit(final String storageUnitName) {
+ Map<String, Object> props = new LinkedHashMap<>(2, 1F);
+ props.put("url", "jdbc:mock://127.0.0.1/" + storageUnitName);
+ props.put("username", "root");
+ StorageUnit result = mock(StorageUnit.class, RETURNS_DEEP_STUBS);
+ when(result.getDataSourcePoolProperties()).thenReturn(new
DataSourcePoolProperties("HikariCP", props));
+ when(result.getDataSource()).thenReturn(new MockedDataSource());
+ return result;
+ }
+
+ private ResourceMetaData createResourceMetaDataWithSingleUnit() {
+ Map<StorageNode, DataSource> dataSources =
Collections.singletonMap(new StorageNode("foo_ds"), new MockedDataSource());
+ Map<String, StorageUnit> storageUnits =
Collections.singletonMap("foo_ds", createStorageUnit("foo_ds"));
+ return new ResourceMetaData(dataSources, storageUnits);
+ }
+
+ private ShardingSphereSchema createSchemaWithTable(final String
schemaName, final String tableName) {
+ Collection<ShardingSphereColumn> columns =
Collections.singletonList(new ShardingSphereColumn("id", 0, true, false, false,
true, false, true));
+ ShardingSphereTable table = new ShardingSphereTable(tableName,
columns, Collections.emptyList(), Collections.emptyList());
+ return new ShardingSphereSchema(schemaName,
Collections.singleton(table), Collections.emptyList());
+ }
}
