This is an automated email from the ASF dual-hosted git repository.
duanzhengqiang 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 8f62e30a4b3 Add test cases on DatabaseMetaDataPersistService (#32978)
8f62e30a4b3 is described below
commit 8f62e30a4b3c218147284e094040f50f12cf1bd4
Author: Liang Zhang <[email protected]>
AuthorDate: Tue Sep 24 14:48:26 2024 +0800
Add test cases on DatabaseMetaDataPersistService (#32978)
---
.../database/DatabaseMetaDataPersistService.java | 5 +-
.../DatabaseMetaDataPersistServiceTest.java | 177 +++++++++++++++++++++
2 files changed, 179 insertions(+), 3 deletions(-)
diff --git
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/database/DatabaseMetaDataPersistService.java
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/database/DatabaseMetaDataPersistService.java
index e0fdcbec3f1..0915bd977c7 100644
---
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/database/DatabaseMetaDataPersistService.java
+++
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/database/DatabaseMetaDataPersistService.java
@@ -17,6 +17,7 @@
package org.apache.shardingsphere.metadata.persist.service.database;
+import lombok.AccessLevel;
import lombok.Getter;
import
org.apache.shardingsphere.infra.metadata.database.schema.manager.GenericSchemaManager;
import
org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereSchema;
@@ -37,17 +38,15 @@ import java.util.Map;
@Getter
public final class DatabaseMetaDataPersistService {
+ @Getter(AccessLevel.NONE)
private final PersistRepository repository;
private final TableMetaDataPersistService tableMetaDataPersistService;
private final ViewMetaDataPersistService viewMetaDataPersistService;
- private final MetaDataVersionPersistService metaDataVersionPersistService;
-
public DatabaseMetaDataPersistService(final PersistRepository repository,
final MetaDataVersionPersistService metaDataVersionPersistService) {
this.repository = repository;
- this.metaDataVersionPersistService = metaDataVersionPersistService;
tableMetaDataPersistService = new
TableMetaDataPersistService(repository, metaDataVersionPersistService);
viewMetaDataPersistService = new
ViewMetaDataPersistService(repository, metaDataVersionPersistService);
}
diff --git
a/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/service/database/DatabaseMetaDataPersistServiceTest.java
b/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/service/database/DatabaseMetaDataPersistServiceTest.java
new file mode 100644
index 00000000000..8fe6de3531e
--- /dev/null
+++
b/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/service/database/DatabaseMetaDataPersistServiceTest.java
@@ -0,0 +1,177 @@
+/*
+ * 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.database;
+
+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.database.schema.model.ShardingSphereView;
+import
org.apache.shardingsphere.metadata.persist.service.schema.TableMetaDataPersistService;
+import
org.apache.shardingsphere.metadata.persist.service.schema.ViewMetaDataPersistService;
+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.internal.configuration.plugins.Plugins;
+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.mockito.Mockito.RETURNS_DEEP_STUBS;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class DatabaseMetaDataPersistServiceTest {
+
+ private DatabaseMetaDataPersistService persistService;
+
+ @Mock
+ private PersistRepository repository;
+
+ @Mock
+ private TableMetaDataPersistService tableMetaDataPersistService;
+
+ @Mock
+ private ViewMetaDataPersistService viewMetaDataPersistService;
+
+ @BeforeEach
+ void setUp() throws ReflectiveOperationException {
+ persistService = new DatabaseMetaDataPersistService(repository,
mock(MetaDataVersionPersistService.class));
+
Plugins.getMemberAccessor().set(DatabaseMetaDataPersistService.class.getDeclaredField("tableMetaDataPersistService"),
persistService, tableMetaDataPersistService);
+
Plugins.getMemberAccessor().set(DatabaseMetaDataPersistService.class.getDeclaredField("viewMetaDataPersistService"),
persistService, viewMetaDataPersistService);
+ }
+
+ @Test
+ void assertAddDatabase() {
+ persistService.addDatabase("foo_db");
+ verify(repository).persist("/metadata/foo_db", "");
+ }
+
+ @Test
+ void assertDropDatabase() {
+ persistService.dropDatabase("foo_db");
+ verify(repository).delete("/metadata/foo_db");
+ }
+
+ @Test
+ void assertLoadAllDatabaseNames() {
+
when(repository.getChildrenKeys("/metadata")).thenReturn(Collections.singletonList("foo"));
+ assertThat(persistService.loadAllDatabaseNames(),
is(Collections.singletonList("foo")));
+ }
+
+ @Test
+ void assertAddSchema() {
+ persistService.addSchema("foo_db", "foo_schema");
+
verify(repository).persist("/metadata/foo_db/schemas/foo_schema/tables", "");
+ }
+
+ @Test
+ void assertDropSchema() {
+ persistService.dropSchema("foo_db", "foo_schema");
+ verify(repository).delete("/metadata/foo_db/schemas/foo_schema");
+ }
+
+ @Test
+ void assertCompareAndPersistWithEmptyTablesAndViews() {
+ persistService.compareAndPersist("foo_db", "foo_schema",
mock(ShardingSphereSchema.class));
+
verify(repository).persist("/metadata/foo_db/schemas/foo_schema/tables", "");
+ verify(tableMetaDataPersistService).persist("foo_db", "foo_schema",
Collections.emptyMap());
+ }
+
+ @Test
+ void assertCompareAndPersistWithNotEmptyTables() {
+ ShardingSphereSchema schema = mock(ShardingSphereSchema.class,
RETURNS_DEEP_STUBS);
+ when(schema.getTables()).thenReturn(Collections.emptyMap());
+ persistService.compareAndPersist("foo_db", "foo_schema", schema);
+ verify(repository,
times(0)).persist("/metadata/foo_db/schemas/foo_schema/tables", "");
+ verify(tableMetaDataPersistService).persist("foo_db", "foo_schema",
Collections.emptyMap());
+ }
+
+ @Test
+ void assertCompareAndPersistWithNotEmptyViews() {
+ ShardingSphereSchema schema = mock(ShardingSphereSchema.class,
RETURNS_DEEP_STUBS);
+ ShardingSphereTable table = mock(ShardingSphereTable.class);
+
when(schema.getTables()).thenReturn(Collections.singletonMap("foo_tbl", table));
+ when(schema.getViews()).thenReturn(Collections.emptyMap());
+ persistService.compareAndPersist("foo_db", "foo_schema", schema);
+ verify(repository,
times(0)).persist("/metadata/foo_db/schemas/foo_schema/tables", "");
+ verify(tableMetaDataPersistService).persist("foo_db", "foo_schema",
Collections.singletonMap("foo_tbl", table));
+ }
+
+ @Test
+ void assertDelete() {
+ ShardingSphereSchema schema = mock(ShardingSphereSchema.class);
+ ShardingSphereTable table = mock(ShardingSphereTable.class);
+
when(schema.getTables()).thenReturn(Collections.singletonMap("foo_tbl", table));
+ persistService.delete("foo_db", "foo_schema", schema);
+ verify(tableMetaDataPersistService).delete("foo_db", "foo_schema",
"foo_tbl");
+ }
+
+ @Test
+ void assertLoadSchemas() {
+
when(repository.getChildrenKeys("/metadata/foo_db/schemas")).thenReturn(Collections.singletonList("foo_schema"));
+ ShardingSphereTable table = mock(ShardingSphereTable.class);
+ when(tableMetaDataPersistService.load("foo_db",
"foo_schema")).thenReturn(Collections.singletonMap("foo_tbl", table));
+ ShardingSphereView view = mock(ShardingSphereView.class);
+ when(viewMetaDataPersistService.load("foo_db",
"foo_schema")).thenReturn(Collections.singletonMap("foo_view", view));
+ Map<String, ShardingSphereSchema> actual =
persistService.loadSchemas("foo_db");
+ assertThat(actual.size(), is(1));
+ assertThat(actual.get("foo_schema").getTable("foo_tbl"), is(table));
+ assertThat(actual.get("foo_schema").getView("foo_view"), is(view));
+ }
+
+ @Test
+ void assertPersistByAlterConfiguration() {
+ persistService.persistByAlterConfiguration("foo_db", "foo_schema",
mock(ShardingSphereSchema.class));
+
verify(repository).persist("/metadata/foo_db/schemas/foo_schema/tables", "");
+ verify(tableMetaDataPersistService).persist("foo_db", "foo_schema",
Collections.emptyMap());
+ }
+
+ @Test
+ void assertPersistByAlterConfigurationWithNotEmptyTables() {
+ ShardingSphereSchema schema = mock(ShardingSphereSchema.class,
RETURNS_DEEP_STUBS);
+ when(schema.getTables()).thenReturn(Collections.emptyMap());
+ persistService.persistByAlterConfiguration("foo_db", "foo_schema",
schema);
+ verify(repository,
times(0)).persist("/metadata/foo_db/schemas/foo_schema/tables", "");
+ verify(tableMetaDataPersistService).persist("foo_db", "foo_schema",
Collections.emptyMap());
+ }
+
+ @Test
+ void assertPersistByAlterConfigurationWithNotEmptyViews() {
+ ShardingSphereSchema schema = mock(ShardingSphereSchema.class,
RETURNS_DEEP_STUBS);
+ ShardingSphereTable table = mock(ShardingSphereTable.class);
+
when(schema.getTables()).thenReturn(Collections.singletonMap("foo_tbl", table));
+ when(schema.getViews()).thenReturn(Collections.emptyMap());
+ persistService.persistByAlterConfiguration("foo_db", "foo_schema",
schema);
+ verify(repository,
times(0)).persist("/metadata/foo_db/schemas/foo_schema/tables", "");
+ verify(tableMetaDataPersistService).persist("foo_db", "foo_schema",
Collections.singletonMap("foo_tbl", table));
+ }
+
+ @Test
+ void assertPersistByDropConfiguration() {
+ persistService.persistByDropConfiguration("foo_db", "foo_schema",
mock(ShardingSphereSchema.class));
+ verify(tableMetaDataPersistService).persist("foo_db", "foo_schema",
Collections.emptyMap());
+ }
+}
