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 97f53dcae0b Add test cases on ShardingSphereDataDispatchEventBuilder
(#32905)
97f53dcae0b is described below
commit 97f53dcae0b7bba062b773e6d0bf1a4cac97d010
Author: Liang Zhang <[email protected]>
AuthorDate: Mon Sep 16 20:31:21 2024 +0800
Add test cases on ShardingSphereDataDispatchEventBuilder (#32905)
* Add test cases on ShardingSphereDataDispatchEventBuilder
* Add test cases on ShardingSphereDataDispatchEventBuilder
* Add test cases on ShardingSphereDataDispatchEventBuilder
* Add test cases on ShardingSphereDataDispatchEventBuilder
---
.../ShardingSphereDataDispatchEventBuilder.java | 129 ++++++-------
...ShardingSphereDataDispatchEventBuilderTest.java | 201 +++++++++++++++++++++
2 files changed, 254 insertions(+), 76 deletions(-)
diff --git
a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/event/builder/ShardingSphereDataDispatchEventBuilder.java
b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/event/builder/ShardingSphereDataDispatchEventBuilder.java
index 67058dca9f1..30bde19a65a 100644
---
a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/event/builder/ShardingSphereDataDispatchEventBuilder.java
+++
b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/event/builder/ShardingSphereDataDispatchEventBuilder.java
@@ -17,7 +17,6 @@
package org.apache.shardingsphere.mode.manager.cluster.event.builder;
-import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
import org.apache.shardingsphere.infra.util.yaml.YamlEngine;
import
org.apache.shardingsphere.infra.yaml.data.pojo.YamlShardingSphereRowData;
@@ -54,101 +53,79 @@ public final class ShardingSphereDataDispatchEventBuilder
implements DispatchEve
@Override
public Optional<DispatchEvent> build(final DataChangedEvent event) {
- if (isDatabaseChanged(event)) {
- return createDatabaseChangedEvent(event);
+ Optional<String> databaseName =
ShardingSphereDataNode.getDatabaseName(event.getKey());
+ if (databaseName.isPresent()) {
+ return createDatabaseChangedEvent(event, databaseName.get());
}
- if (isSchemaChanged(event)) {
- return createSchemaChangedEvent(event);
+ databaseName =
ShardingSphereDataNode.getDatabaseNameByDatabasePath(event.getKey());
+ if (!databaseName.isPresent()) {
+ return Optional.empty();
}
- if (isTableChanged(event)) {
- return createTableChangedEvent(event);
+ Optional<String> schemaName =
ShardingSphereDataNode.getSchemaName(event.getKey());
+ if (schemaName.isPresent()) {
+ return createSchemaChangedEvent(event, databaseName.get(),
schemaName.get());
}
- if (isTableRowDataChanged(event)) {
- return createRowDataChangedEvent(event);
+ schemaName =
ShardingSphereDataNode.getSchemaNameBySchemaPath(event.getKey());
+ if (!schemaName.isPresent()) {
+ return Optional.empty();
}
- return Optional.empty();
- }
-
- private boolean isDatabaseChanged(final DataChangedEvent event) {
- return
ShardingSphereDataNode.getDatabaseName(event.getKey()).isPresent();
- }
-
- private boolean isSchemaChanged(final DataChangedEvent event) {
- return
ShardingSphereDataNode.getDatabaseNameByDatabasePath(event.getKey()).isPresent()
&& ShardingSphereDataNode.getSchemaName(event.getKey()).isPresent();
- }
-
- private boolean isTableChanged(final DataChangedEvent event) {
- Optional<String> databaseName =
ShardingSphereDataNode.getDatabaseNameByDatabasePath(event.getKey());
- Optional<String> schemaName =
ShardingSphereDataNode.getSchemaNameBySchemaPath(event.getKey());
Optional<String> tableName =
ShardingSphereDataNode.getTableName(event.getKey());
- return databaseName.isPresent() && schemaName.isPresent() &&
tableName.isPresent();
- }
-
- private boolean isTableRowDataChanged(final DataChangedEvent event) {
- return
ShardingSphereDataNode.getRowUniqueKey(event.getKey()).isPresent();
- }
-
- private Optional<DispatchEvent> createDatabaseChangedEvent(final
DataChangedEvent event) {
- Optional<String> databaseName =
ShardingSphereDataNode.getDatabaseName(event.getKey());
- Preconditions.checkState(databaseName.isPresent());
- if (Type.ADDED == event.getType() || Type.UPDATED == event.getType()) {
- return Optional.of(new DatabaseDataAddedEvent(databaseName.get()));
+ if (tableName.isPresent()) {
+ return createTableChangedEvent(event, databaseName.get(),
schemaName.get(), tableName.get());
}
- if (Type.DELETED == event.getType()) {
- return Optional.of(new
DatabaseDataDeletedEvent(databaseName.get()));
+ tableName =
ShardingSphereDataNode.getTableNameByRowPath(event.getKey());
+ if (!tableName.isPresent()) {
+ return Optional.empty();
+ }
+ Optional<String> rowPath =
ShardingSphereDataNode.getRowUniqueKey(event.getKey());
+ if (rowPath.isPresent()) {
+ return createRowDataChangedEvent(event, databaseName.get(),
schemaName.get(), tableName.get(), rowPath.get());
}
return Optional.empty();
}
- private Optional<DispatchEvent> createSchemaChangedEvent(final
DataChangedEvent event) {
- Optional<String> databaseName =
ShardingSphereDataNode.getDatabaseNameByDatabasePath(event.getKey());
- Preconditions.checkState(databaseName.isPresent());
- Optional<String> schemaName =
ShardingSphereDataNode.getSchemaName(event.getKey());
- Preconditions.checkState(schemaName.isPresent());
- if (Type.ADDED == event.getType() || Type.UPDATED == event.getType()) {
- return Optional.of(new SchemaDataAddedEvent(databaseName.get(),
schemaName.get()));
+ private Optional<DispatchEvent> createDatabaseChangedEvent(final
DataChangedEvent event, final String databaseName) {
+ switch (event.getType()) {
+ case ADDED:
+ case UPDATED:
+ return Optional.of(new DatabaseDataAddedEvent(databaseName));
+ case DELETED:
+ return Optional.of(new DatabaseDataDeletedEvent(databaseName));
+ default:
+ return Optional.empty();
}
- if (Type.DELETED == event.getType()) {
- return Optional.of(new SchemaDataDeletedEvent(databaseName.get(),
schemaName.get()));
- }
- return Optional.empty();
}
- private Optional<DispatchEvent> createTableChangedEvent(final
DataChangedEvent event) {
- Optional<String> databaseName =
ShardingSphereDataNode.getDatabaseNameByDatabasePath(event.getKey());
- Preconditions.checkState(databaseName.isPresent());
- Optional<String> schemaName =
ShardingSphereDataNode.getSchemaNameBySchemaPath(event.getKey());
- Preconditions.checkState(schemaName.isPresent());
- return doCreateTableChangedEvent(event, databaseName.get(),
schemaName.get());
+ private Optional<DispatchEvent> createSchemaChangedEvent(final
DataChangedEvent event, final String databaseName, final String schemaName) {
+ switch (event.getType()) {
+ case ADDED:
+ case UPDATED:
+ return Optional.of(new SchemaDataAddedEvent(databaseName,
schemaName));
+ case DELETED:
+ return Optional.of(new SchemaDataDeletedEvent(databaseName,
schemaName));
+ default:
+ return Optional.empty();
+ }
}
- private Optional<DispatchEvent> doCreateTableChangedEvent(final
DataChangedEvent event, final String databaseName, final String schemaName) {
- Optional<String> tableName =
ShardingSphereDataNode.getTableName(event.getKey());
- Preconditions.checkState(tableName.isPresent());
- if (Type.ADDED == event.getType() || Type.UPDATED == event.getType()) {
- return Optional.of(new TableDataChangedEvent(databaseName,
schemaName, tableName.get(), null));
- }
- if (Type.DELETED == event.getType()) {
- return Optional.of(new TableDataChangedEvent(databaseName,
schemaName, null, tableName.get()));
+ private Optional<DispatchEvent> createTableChangedEvent(final
DataChangedEvent event, final String databaseName, final String schemaName,
final String tableName) {
+ switch (event.getType()) {
+ case ADDED:
+ case UPDATED:
+ return Optional.of(new TableDataChangedEvent(databaseName,
schemaName, tableName, null));
+ case DELETED:
+ return Optional.of(new TableDataChangedEvent(databaseName,
schemaName, null, tableName));
+ default:
+ return Optional.empty();
}
- return Optional.empty();
}
- private Optional<DispatchEvent> createRowDataChangedEvent(final
DataChangedEvent event) {
- Optional<String> databaseName =
ShardingSphereDataNode.getDatabaseNameByDatabasePath(event.getKey());
- Preconditions.checkState(databaseName.isPresent());
- Optional<String> schemaName =
ShardingSphereDataNode.getSchemaNameBySchemaPath(event.getKey());
- Preconditions.checkState(schemaName.isPresent());
- Optional<String> tableName =
ShardingSphereDataNode.getTableNameByRowPath(event.getKey());
- Preconditions.checkState(tableName.isPresent());
- Optional<String> rowPath =
ShardingSphereDataNode.getRowUniqueKey(event.getKey());
- Preconditions.checkState(rowPath.isPresent());
- if (Type.ADDED == event.getType() || Type.UPDATED == event.getType()
&& !Strings.isNullOrEmpty(event.getValue())) {
- YamlShardingSphereRowData yamlShardingSphereRowData =
YamlEngine.unmarshal(event.getValue(), YamlShardingSphereRowData.class);
- return Optional.of(new
ShardingSphereRowDataChangedEvent(databaseName.get(), schemaName.get(),
tableName.get(), yamlShardingSphereRowData));
+ private Optional<DispatchEvent> createRowDataChangedEvent(final
DataChangedEvent event, final String databaseName, final String schemaName,
final String tableName, final String rowPath) {
+ if ((Type.ADDED == event.getType() || Type.UPDATED == event.getType())
&& !Strings.isNullOrEmpty(event.getValue())) {
+ return Optional.of(new
ShardingSphereRowDataChangedEvent(databaseName, schemaName, tableName,
YamlEngine.unmarshal(event.getValue(), YamlShardingSphereRowData.class)));
}
if (Type.DELETED == event.getType()) {
- return Optional.of(new
ShardingSphereRowDataDeletedEvent(databaseName.get(), schemaName.get(),
tableName.get(), rowPath.get()));
+ return Optional.of(new
ShardingSphereRowDataDeletedEvent(databaseName, schemaName, tableName,
rowPath));
}
return Optional.empty();
}
diff --git
a/mode/type/cluster/core/src/test/java/org/apache/shardingsphere/mode/manager/cluster/event/builder/ShardingSphereDataDispatchEventBuilderTest.java
b/mode/type/cluster/core/src/test/java/org/apache/shardingsphere/mode/manager/cluster/event/builder/ShardingSphereDataDispatchEventBuilderTest.java
new file mode 100644
index 00000000000..82bb09f557f
--- /dev/null
+++
b/mode/type/cluster/core/src/test/java/org/apache/shardingsphere/mode/manager/cluster/event/builder/ShardingSphereDataDispatchEventBuilderTest.java
@@ -0,0 +1,201 @@
+/*
+ * 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.mode.manager.cluster.event.builder;
+
+import org.apache.shardingsphere.mode.event.DataChangedEvent;
+import org.apache.shardingsphere.mode.event.DataChangedEvent.Type;
+import org.apache.shardingsphere.mode.event.dispatch.DispatchEvent;
+import
org.apache.shardingsphere.mode.event.dispatch.metadata.data.DatabaseDataAddedEvent;
+import
org.apache.shardingsphere.mode.event.dispatch.metadata.data.DatabaseDataDeletedEvent;
+import
org.apache.shardingsphere.mode.event.dispatch.metadata.data.SchemaDataAddedEvent;
+import
org.apache.shardingsphere.mode.event.dispatch.metadata.data.SchemaDataDeletedEvent;
+import
org.apache.shardingsphere.mode.event.dispatch.metadata.data.ShardingSphereRowDataChangedEvent;
+import
org.apache.shardingsphere.mode.event.dispatch.metadata.data.ShardingSphereRowDataDeletedEvent;
+import
org.apache.shardingsphere.mode.event.dispatch.metadata.data.TableDataChangedEvent;
+import org.junit.jupiter.api.Test;
+
+import java.util.Optional;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class ShardingSphereDataDispatchEventBuilderTest {
+
+ private final ShardingSphereDataDispatchEventBuilder builder = new
ShardingSphereDataDispatchEventBuilder();
+
+ @Test
+ void assertGetSubscribedKey() {
+ assertThat(builder.getSubscribedKey(), is("/statistics/databases"));
+ }
+
+ @Test
+ void assertBuildDatabaseDataChangedEventWithAdd() {
+ Optional<DispatchEvent> actual = builder.build(new
DataChangedEvent("/statistics/databases/foo_db", "", Type.ADDED));
+ assertTrue(actual.isPresent());
+ assertThat(((DatabaseDataAddedEvent) actual.get()).getDatabaseName(),
is("foo_db"));
+ }
+
+ @Test
+ void assertBuildDatabaseDataChangedEventWithUpdate() {
+ Optional<DispatchEvent> actual = builder.build(new
DataChangedEvent("/statistics/databases/foo_db", "", Type.UPDATED));
+ assertTrue(actual.isPresent());
+ assertThat(((DatabaseDataAddedEvent) actual.get()).getDatabaseName(),
is("foo_db"));
+ }
+
+ @Test
+ void assertBuildDatabaseDataChangedEventWithDelete() {
+ Optional<DispatchEvent> actual = builder.build(new
DataChangedEvent("/statistics/databases/foo_db", "", Type.DELETED));
+ assertTrue(actual.isPresent());
+ assertThat(((DatabaseDataDeletedEvent)
actual.get()).getDatabaseName(), is("foo_db"));
+ }
+
+ @Test
+ void assertBuildDatabaseDataChangedEventWithIgnore() {
+ Optional<DispatchEvent> actual = builder.build(new
DataChangedEvent("/statistics/databases/foo_db", "", Type.IGNORED));
+ assertFalse(actual.isPresent());
+ }
+
+ @Test
+ void assertBuildSchemaDataChangedEventWithAdd() {
+ Optional<DispatchEvent> actual = builder.build(new
DataChangedEvent("/statistics/databases/foo_db/schemas/foo_schema", "",
Type.ADDED));
+ assertTrue(actual.isPresent());
+ assertThat(((SchemaDataAddedEvent) actual.get()).getDatabaseName(),
is("foo_db"));
+ assertThat(((SchemaDataAddedEvent) actual.get()).getSchemaName(),
is("foo_schema"));
+ }
+
+ @Test
+ void assertBuildSchemaDataChangedEventWithUpdate() {
+ Optional<DispatchEvent> actual = builder.build(new
DataChangedEvent("/statistics/databases/foo_db/schemas/foo_schema", "",
Type.UPDATED));
+ assertTrue(actual.isPresent());
+ assertThat(((SchemaDataAddedEvent) actual.get()).getDatabaseName(),
is("foo_db"));
+ assertThat(((SchemaDataAddedEvent) actual.get()).getSchemaName(),
is("foo_schema"));
+ }
+
+ @Test
+ void assertBuildSchemaDataChangedEventWithDelete() {
+ Optional<DispatchEvent> actual = builder.build(new
DataChangedEvent("/statistics/databases/foo_db/schemas/foo_schema", "",
Type.DELETED));
+ assertTrue(actual.isPresent());
+ assertThat(((SchemaDataDeletedEvent) actual.get()).getDatabaseName(),
is("foo_db"));
+ assertThat(((SchemaDataDeletedEvent) actual.get()).getSchemaName(),
is("foo_schema"));
+ }
+
+ @Test
+ void assertBuildSchemaDataChangedEventWithIgnore() {
+ Optional<DispatchEvent> actual = builder.build(new
DataChangedEvent("/statistics/databases/foo_db/schemas/foo_schema", "",
Type.IGNORED));
+ assertFalse(actual.isPresent());
+ }
+
+ @Test
+ void assertBuildTableDataChangedEventWithAdd() {
+ Optional<DispatchEvent> actual = builder.build(new
DataChangedEvent("/statistics/databases/foo_db/schemas/foo_schema/tables/foo_tbl",
"", Type.ADDED));
+ assertTrue(actual.isPresent());
+ assertThat(((TableDataChangedEvent) actual.get()).getDatabaseName(),
is("foo_db"));
+ assertThat(((TableDataChangedEvent) actual.get()).getSchemaName(),
is("foo_schema"));
+ assertThat(((TableDataChangedEvent) actual.get()).getAddedTable(),
is("foo_tbl"));
+ assertNull(((TableDataChangedEvent) actual.get()).getDeletedTable());
+ }
+
+ @Test
+ void assertBuildTableDataChangedEventWithUpdate() {
+ Optional<DispatchEvent> actual = builder.build(new
DataChangedEvent("/statistics/databases/foo_db/schemas/foo_schema/tables/foo_tbl",
"", Type.UPDATED));
+ assertTrue(actual.isPresent());
+ assertThat(((TableDataChangedEvent) actual.get()).getDatabaseName(),
is("foo_db"));
+ assertThat(((TableDataChangedEvent) actual.get()).getSchemaName(),
is("foo_schema"));
+ assertThat(((TableDataChangedEvent) actual.get()).getAddedTable(),
is("foo_tbl"));
+ assertNull(((TableDataChangedEvent) actual.get()).getDeletedTable());
+ }
+
+ @Test
+ void assertBuildTableDataChangedEventWithDelete() {
+ Optional<DispatchEvent> actual = builder.build(new
DataChangedEvent("/statistics/databases/foo_db/schemas/foo_schema/tables/foo_tbl",
"", Type.DELETED));
+ assertTrue(actual.isPresent());
+ assertThat(((TableDataChangedEvent) actual.get()).getDatabaseName(),
is("foo_db"));
+ assertThat(((TableDataChangedEvent) actual.get()).getSchemaName(),
is("foo_schema"));
+ assertNull(((TableDataChangedEvent) actual.get()).getAddedTable());
+ assertThat(((TableDataChangedEvent) actual.get()).getDeletedTable(),
is("foo_tbl"));
+ }
+
+ @Test
+ void assertBuildTableDataChangedEventWithIgnore() {
+ Optional<DispatchEvent> actual = builder.build(new
DataChangedEvent("/statistics/databases/foo_db/schemas/foo_schema/tables/foo_tbl",
"", Type.IGNORED));
+ assertFalse(actual.isPresent());
+ }
+
+ @Test
+ void assertBuildRowDataChangedEventWithAdd() {
+ Optional<DispatchEvent> actual = builder.build(new
DataChangedEvent("/statistics/databases/foo_db/schemas/foo_schema/tables/foo_tbl/xxx",
"{uniqueKey: 1}", Type.ADDED));
+ assertTrue(actual.isPresent());
+ assertThat(((ShardingSphereRowDataChangedEvent)
actual.get()).getDatabaseName(), is("foo_db"));
+ assertThat(((ShardingSphereRowDataChangedEvent)
actual.get()).getSchemaName(), is("foo_schema"));
+ assertThat(((ShardingSphereRowDataChangedEvent)
actual.get()).getTableName(), is("foo_tbl"));
+ assertThat(((ShardingSphereRowDataChangedEvent)
actual.get()).getYamlRowData().getUniqueKey(), is("1"));
+ }
+
+ @Test
+ void assertBuildRowDataChangedEventWithUpdate() {
+ Optional<DispatchEvent> actual = builder.build(new
DataChangedEvent("/statistics/databases/foo_db/schemas/foo_schema/tables/foo_tbl/1",
"{uniqueKey: 1}", Type.UPDATED));
+ assertTrue(actual.isPresent());
+ assertThat(((ShardingSphereRowDataChangedEvent)
actual.get()).getDatabaseName(), is("foo_db"));
+ assertThat(((ShardingSphereRowDataChangedEvent)
actual.get()).getSchemaName(), is("foo_schema"));
+ assertThat(((ShardingSphereRowDataChangedEvent)
actual.get()).getTableName(), is("foo_tbl"));
+ assertThat(((ShardingSphereRowDataChangedEvent)
actual.get()).getYamlRowData().getUniqueKey(), is("1"));
+ }
+
+ @Test
+ void assertBuildRowDataChangedEventWithDelete() {
+ Optional<DispatchEvent> actual = builder.build(new
DataChangedEvent("/statistics/databases/foo_db/schemas/foo_schema/tables/foo_tbl/1",
"", Type.DELETED));
+ assertTrue(actual.isPresent());
+ assertThat(((ShardingSphereRowDataDeletedEvent)
actual.get()).getDatabaseName(), is("foo_db"));
+ assertThat(((ShardingSphereRowDataDeletedEvent)
actual.get()).getSchemaName(), is("foo_schema"));
+ assertThat(((ShardingSphereRowDataDeletedEvent)
actual.get()).getTableName(), is("foo_tbl"));
+ assertThat(((ShardingSphereRowDataDeletedEvent)
actual.get()).getUniqueKey(), is("1"));
+ }
+
+ @Test
+ void assertBuildRowDataChangedEventWithAddNullValue() {
+ Optional<DispatchEvent> actual = builder.build(new
DataChangedEvent("/statistics/databases/foo_db/schemas/foo_schema/tables/foo_tbl/1",
"", Type.ADDED));
+ assertFalse(actual.isPresent());
+ }
+
+ @Test
+ void assertBuildWithMissedDatabaseNameEventKey() {
+ Optional<DispatchEvent> actual = builder.build(new
DataChangedEvent("/statistics/databases", "", Type.ADDED));
+ assertFalse(actual.isPresent());
+ }
+
+ @Test
+ void assertBuildWithMissedSchemaNameEventKey() {
+ Optional<DispatchEvent> actual = builder.build(new
DataChangedEvent("/statistics/databases/foo_db/schemas", "", Type.ADDED));
+ assertFalse(actual.isPresent());
+ }
+
+ @Test
+ void assertBuildWithMissedTableNameEventKey() {
+ Optional<DispatchEvent> actual = builder.build(new
DataChangedEvent("/statistics/databases/foo_db/schemas/foo_schema/tables", "",
Type.ADDED));
+ assertFalse(actual.isPresent());
+ }
+
+ @Test
+ void assertBuildWithMissedRowEventKey() {
+ Optional<DispatchEvent> actual = builder.build(new
DataChangedEvent("/statistics/databases/foo_db/schemas/foo_schema/tables/foo_tbl/",
"", Type.ADDED));
+ assertFalse(actual.isPresent());
+ }
+}
