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 573531d6957 Add test cases on TableMetaDataPersistService (#32982)
573531d6957 is described below
commit 573531d69570191693099fa5d405576eca9e536e
Author: Liang Zhang <[email protected]>
AuthorDate: Tue Sep 24 20:14:59 2024 +0800
Add test cases on TableMetaDataPersistService (#32982)
---
.../schema/TableMetaDataPersistService.java | 27 +++----
.../schema/TableMetaDataPersistServiceTest.java | 94 ++++++++++++++++++++++
2 files changed, 107 insertions(+), 14 deletions(-)
diff --git
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/schema/TableMetaDataPersistService.java
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/schema/TableMetaDataPersistService.java
index 4562f5ea9a5..3df33a65db5 100644
---
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/schema/TableMetaDataPersistService.java
+++
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/schema/TableMetaDataPersistService.java
@@ -35,6 +35,7 @@ import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
/**
* Table meta data persist service.
@@ -53,7 +54,7 @@ public final class TableMetaDataPersistService implements
SchemaMetaDataPersistS
String tableName = entry.getKey().toLowerCase();
List<String> versions =
repository.getChildrenKeys(TableMetaDataNode.getTableVersionsNode(databaseName,
schemaName, tableName));
String nextActiveVersion = versions.isEmpty() ?
MetaDataVersion.DEFAULT_VERSION :
String.valueOf(Integer.parseInt(versions.get(0)) + 1);
- if (entry.getValue() != null) {
+ if (null != entry.getValue()) {
repository.persist(TableMetaDataNode.getTableVersionNode(databaseName,
schemaName, tableName, nextActiveVersion),
YamlEngine.marshal(new
YamlTableSwapper().swapToYamlConfiguration(entry.getValue())));
}
@@ -71,25 +72,23 @@ public final class TableMetaDataPersistService implements
SchemaMetaDataPersistS
@Override
public Map<String, ShardingSphereTable> load(final String databaseName,
final String schemaName) {
- Collection<String> tableNames =
repository.getChildrenKeys(TableMetaDataNode.getMetaDataTablesNode(databaseName,
schemaName));
- return tableNames.isEmpty() ? Collections.emptyMap() :
getTableMetaDataByTableNames(databaseName, schemaName, tableNames);
+ List<String> tableNames =
repository.getChildrenKeys(TableMetaDataNode.getMetaDataTablesNode(databaseName,
schemaName));
+ Map<String, ShardingSphereTable> result = new
LinkedHashMap<>(tableNames.size(), 1F);
+ for (String each : tableNames) {
+ getTableMetaData(databaseName, schemaName,
each).ifPresent(optional -> result.put(each.toLowerCase(), optional));
+ }
+ return result;
}
@Override
public Map<String, ShardingSphereTable> load(final String databaseName,
final String schemaName, final String tableName) {
- return getTableMetaDataByTableNames(databaseName, schemaName,
Collections.singletonList(tableName));
+ return getTableMetaData(databaseName, schemaName,
tableName).map(optional -> Collections.singletonMap(tableName.toLowerCase(),
optional)).orElse(Collections.emptyMap());
}
- private Map<String, ShardingSphereTable>
getTableMetaDataByTableNames(final String databaseName, final String
schemaName, final Collection<String> tableNames) {
- Map<String, ShardingSphereTable> result = new
LinkedHashMap<>(tableNames.size(), 1F);
- tableNames.forEach(each -> {
- String table =
repository.query(TableMetaDataNode.getTableVersionNode(databaseName,
schemaName, each,
-
repository.query(TableMetaDataNode.getTableActiveVersionNode(databaseName,
schemaName, each))));
- if (!Strings.isNullOrEmpty(table)) {
- result.put(each.toLowerCase(), new
YamlTableSwapper().swapToObject(YamlEngine.unmarshal(table,
YamlShardingSphereTable.class)));
- }
- });
- return result;
+ private Optional<ShardingSphereTable> getTableMetaData(final String
databaseName, final String schemaName, final String tableName) {
+ String tableContent =
repository.query(TableMetaDataNode.getTableVersionNode(databaseName,
schemaName, tableName,
+
repository.query(TableMetaDataNode.getTableActiveVersionNode(databaseName,
schemaName, tableName))));
+ return Strings.isNullOrEmpty(tableContent) ? Optional.empty() :
Optional.of(new
YamlTableSwapper().swapToObject(YamlEngine.unmarshal(tableContent,
YamlShardingSphereTable.class)));
}
@Override
diff --git
a/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/service/schema/TableMetaDataPersistServiceTest.java
b/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/service/schema/TableMetaDataPersistServiceTest.java
new file mode 100644
index 00000000000..355cbb9064c
--- /dev/null
+++
b/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/service/schema/TableMetaDataPersistServiceTest.java
@@ -0,0 +1,94 @@
+/*
+ * 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.metadata.persist.service.schema;
+
+import
org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereTable;
+import
org.apache.shardingsphere.metadata.persist.node.metadata.TableMetaDataNode;
+import
org.apache.shardingsphere.metadata.persist.service.version.MetaDataVersionPersistService;
+import org.apache.shardingsphere.mode.spi.PersistRepository;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.Collections;
+import java.util.Map;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class TableMetaDataPersistServiceTest {
+
+ private TableMetaDataPersistService persistService;
+
+ @Mock
+ private PersistRepository repository;
+
+ @Mock
+ private MetaDataVersionPersistService metaDataVersionPersistService;
+
+ @BeforeEach
+ void setUp() {
+ persistService = new TableMetaDataPersistService(repository,
metaDataVersionPersistService);
+ }
+
+ @Test
+ void assertPersist() {
+ persistService.persist("foo_db", "foo_schema",
Collections.singletonMap("foo_tbl", mock(ShardingSphereTable.class)));
+
verify(repository).persist("/metadata/foo_db/schemas/foo_schema/tables/foo_tbl/versions/0",
"{}" + System.lineSeparator());
+
verify(repository).persist("/metadata/foo_db/schemas/foo_schema/tables/foo_tbl/active_version",
"0");
+ verify(metaDataVersionPersistService).switchActiveVersion(any());
+ }
+
+ @Test
+ void assertLoadWithEmptyTables() {
+ assertTrue(persistService.load("foo_db", "foo_schema").isEmpty());
+ }
+
+ @Test
+ void assertLoadWithTables() {
+
when(repository.getChildrenKeys("/metadata/foo_db/schemas/foo_schema/tables")).thenReturn(Collections.singletonList("foo_tbl"));
+
when(repository.query("/metadata/foo_db/schemas/foo_schema/tables/foo_tbl/active_version")).thenReturn("0");
+
when(repository.query("/metadata/foo_db/schemas/foo_schema/tables/foo_tbl/versions/0")).thenReturn("{name:
foo_tbl}");
+ Map<String, ShardingSphereTable> actual =
persistService.load("foo_db", "foo_schema");
+ assertThat(actual.size(), is(1));
+ assertThat(actual.get("foo_tbl").getName(), is("foo_tbl"));
+ }
+
+ @Test
+ void assertLoadWithTable() {
+
when(repository.query("/metadata/foo_db/schemas/foo_schema/tables/foo_tbl/active_version")).thenReturn("0");
+
when(repository.query("/metadata/foo_db/schemas/foo_schema/tables/foo_tbl/versions/0")).thenReturn("{name:
foo_tbl}");
+ Map<String, ShardingSphereTable> actual =
persistService.load("foo_db", "foo_schema", "foo_tbl");
+ assertThat(actual.size(), is(1));
+ assertThat(actual.get("foo_tbl").getName(), is("foo_tbl"));
+ }
+
+ @Test
+ void assertDelete() {
+ persistService.delete("foo_db", "foo_schema", "foo_tbl");
+ verify(repository).delete(TableMetaDataNode.getTableNode("foo_db",
"foo_schema", "foo_tbl"));
+ }
+}
