You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by du...@apache.org on 2021/08/13 11:32:35 UTC
[shardingsphere] branch master updated: Refactor
ReadwriteSplittingRuleStatementConverterTest (#11808)
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 aecf666 Refactor ReadwriteSplittingRuleStatementConverterTest (#11808)
aecf666 is described below
commit aecf66666d4af112549fd1639ded7328c968277b
Author: Haoran Meng <me...@gmail.com>
AuthorDate: Fri Aug 13 19:32:07 2021 +0800
Refactor ReadwriteSplittingRuleStatementConverterTest (#11808)
---
...adwriteSplittingRuleStatementConverterTest.java | 86 ++++++++++------------
1 file changed, 38 insertions(+), 48 deletions(-)
diff --git a/shardingsphere-features/shardingsphere-readwrite-splitting/shardingsphere-readwrite-splitting-distsql/shardingsphere-readwrite-splitting-distsql-handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/converter/ReadwriteSplittingRuleStatementConverterTest.java b/shardingsphere-features/shardingsphere-readwrite-splitting/shardingsphere-readwrite-splitting-distsql/shardingsphere-readwrite-splitting-distsql-handler/src/test/java/org/apache/shardingsphe [...]
index 284f5f7..7b86a9d 100644
--- a/shardingsphere-features/shardingsphere-readwrite-splitting/shardingsphere-readwrite-splitting-distsql/shardingsphere-readwrite-splitting-distsql-handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/converter/ReadwriteSplittingRuleStatementConverterTest.java
+++ b/shardingsphere-features/shardingsphere-readwrite-splitting/shardingsphere-readwrite-splitting-distsql/shardingsphere-readwrite-splitting-distsql-handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/converter/ReadwriteSplittingRuleStatementConverterTest.java
@@ -23,6 +23,7 @@ import org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingD
import org.apache.shardingsphere.readwritesplitting.distsql.parser.segment.ReadwriteSplittingRuleSegment;
import org.junit.Test;
+import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Collection;
@@ -31,87 +32,76 @@ import java.util.Map;
import java.util.Properties;
import java.util.stream.Stream;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
public final class ReadwriteSplittingRuleStatementConverterTest {
-
+
@Test
public void assertEmptyRuleSegmentConvertResult() {
ReadwriteSplittingRuleConfiguration actualEmptyRuleSegmentConvertResult = ReadwriteSplittingRuleStatementConverter
.convert(Collections.emptyList());
- assertThat(actualEmptyRuleSegmentConvertResult.getDataSources(), org.hamcrest.Matchers.empty());
- assertThat(actualEmptyRuleSegmentConvertResult.getLoadBalancers().size(), org.hamcrest.Matchers.is(0));
+ assertTrue(actualEmptyRuleSegmentConvertResult.getDataSources().isEmpty());
+ assertTrue(actualEmptyRuleSegmentConvertResult.getLoadBalancers().isEmpty());
}
-
+
@Test
public void assertSingleRuleSegmentConvertResult() {
- Properties properties1 = new Properties();
- properties1.setProperty("ping", "pong");
- ReadwriteSplittingRuleSegment expectedSingleReadwriteSplittingRuleSegment = createReadwriteSplittingRuleSegment("name1", "write_ds_01",
- Arrays.asList("read_ds_01", "read_ds_02"), "lb01", properties1);
+ ReadwriteSplittingRuleSegment expectedSingleReadwriteSplittingRuleSegment = createReadwriteSplittingRuleSegment("static", "write_ds",
+ Arrays.asList("read_ds_01", "read_ds_02"), "static_load_balancer_type", new Properties());
ReadwriteSplittingRuleConfiguration actualSingleRuleSegmentConvertResult = ReadwriteSplittingRuleStatementConverter
.convert(Collections.singleton(expectedSingleReadwriteSplittingRuleSegment));
Collection<ReadwriteSplittingDataSourceRuleConfiguration> actualSingleRuleSegmentConvertResultDataSources = actualSingleRuleSegmentConvertResult.getDataSources();
Map<String, ShardingSphereAlgorithmConfiguration> actualSingleRuleSegmentConvertResultLoadBalancers = actualSingleRuleSegmentConvertResult.getLoadBalancers();
- assertThat(actualSingleRuleSegmentConvertResultDataSources.size(), org.hamcrest.Matchers.is(1));
- assertThat(actualSingleRuleSegmentConvertResultLoadBalancers.size(), org.hamcrest.Matchers.is(1));
- Object[] dataSources = actualSingleRuleSegmentConvertResultDataSources.toArray();
- ReadwriteSplittingDataSourceRuleConfiguration actualRuleConfiguration = (ReadwriteSplittingDataSourceRuleConfiguration) dataSources[0];
- assertThat(actualRuleConfiguration.getName(), org.hamcrest.Matchers.is(expectedSingleReadwriteSplittingRuleSegment.getName()));
+ assertThat(actualSingleRuleSegmentConvertResultDataSources.size(), is(1));
+ assertThat(actualSingleRuleSegmentConvertResultLoadBalancers.size(), is(1));
+ ReadwriteSplittingDataSourceRuleConfiguration actualRuleConfiguration = actualSingleRuleSegmentConvertResultDataSources.iterator().next();
+ assertThat(actualRuleConfiguration.getName(), is(expectedSingleReadwriteSplittingRuleSegment.getName()));
String expectedLoadBalancerName = String.format("%s_%s", expectedSingleReadwriteSplittingRuleSegment.getName(), expectedSingleReadwriteSplittingRuleSegment.getLoadBalancer());
- assertThat(actualRuleConfiguration.getLoadBalancerName(), org.hamcrest.Matchers.is(expectedLoadBalancerName));
- assertThat(actualRuleConfiguration.getWriteDataSourceName(), org.hamcrest.Matchers.is(expectedSingleReadwriteSplittingRuleSegment.getWriteDataSource()));
- assertThat(actualRuleConfiguration.getReadDataSourceNames(),
- org.hamcrest.Matchers.equalTo(expectedSingleReadwriteSplittingRuleSegment.getReadDataSources() == null
- ? Collections.emptyList()
- : expectedSingleReadwriteSplittingRuleSegment.getReadDataSources()));
- String actualLoadBalancerName = actualSingleRuleSegmentConvertResultLoadBalancers.keySet().toArray()[0].toString();
- assertThat(actualLoadBalancerName, org.hamcrest.Matchers.is(expectedLoadBalancerName));
+ assertThat(actualRuleConfiguration.getLoadBalancerName(), is(expectedLoadBalancerName));
+ assertThat(actualRuleConfiguration.getWriteDataSourceName(), is(expectedSingleReadwriteSplittingRuleSegment.getWriteDataSource()));
+ assertThat(actualRuleConfiguration.getReadDataSourceNames(), is(expectedSingleReadwriteSplittingRuleSegment.getReadDataSources()));
+ String actualLoadBalancerName = actualSingleRuleSegmentConvertResultLoadBalancers.keySet().iterator().next();
+ assertThat(actualLoadBalancerName, is(expectedLoadBalancerName));
ShardingSphereAlgorithmConfiguration actualSphereAlgorithmConfiguration = actualSingleRuleSegmentConvertResultLoadBalancers.get(actualLoadBalancerName);
- assertThat(actualSphereAlgorithmConfiguration.getType(), org.hamcrest.Matchers.containsString(expectedSingleReadwriteSplittingRuleSegment.getLoadBalancer()));
- assertThat(actualSphereAlgorithmConfiguration.getProps(), org.hamcrest.Matchers.is(expectedSingleReadwriteSplittingRuleSegment.getProps()));
+ assertThat(actualSphereAlgorithmConfiguration.getType(), containsString(expectedSingleReadwriteSplittingRuleSegment.getLoadBalancer()));
+ assertThat(actualSphereAlgorithmConfiguration.getProps(), is(expectedSingleReadwriteSplittingRuleSegment.getProps()));
}
-
+
@Test
public void assertMultipleReadwriteSplittingRuleSegments() {
- Properties properties2 = new Properties();
- properties2.setProperty("ping1", "pong1");
- Properties properties3 = new Properties();
- properties3.setProperty("ping2", "pong2");
- Properties properties4 = new Properties();
- properties4.setProperty("ping3", "pong3");
- properties4.setProperty("ping4", "pong4");
List<ReadwriteSplittingRuleSegment> expectedMultipleReadwriteSplittingRuleSegments = Arrays.asList(
- createReadwriteSplittingRuleSegment("name2", "write_ds_02", Arrays.asList("read_ds_02", "read_ds_03"), "lb02", properties2),
- createReadwriteSplittingRuleSegment("name3", "write_ds_03", Arrays.asList("read_ds_04", "read_ds_05"), "lb03", properties3),
- createReadwriteSplittingRuleSegment("name4", "autoAwareResource", "lb04", properties4));
+ createReadwriteSplittingRuleSegment("static", "write_ds", Arrays.asList("read_ds_01", "read_ds_02"), "static_load_balancer_type", new Properties()),
+ createReadwriteSplittingRuleSegment("dynamic", "autoAwareResource", "dynamic_load_balancer", new Properties()));
ReadwriteSplittingRuleConfiguration actualMultipleRuleSegmentConvertResult = ReadwriteSplittingRuleStatementConverter.convert(expectedMultipleReadwriteSplittingRuleSegments);
Collection<ReadwriteSplittingDataSourceRuleConfiguration> actualMultipleRuleSegmentConvertResultDataSources = actualMultipleRuleSegmentConvertResult.getDataSources();
Map<String, ShardingSphereAlgorithmConfiguration> actualMultipleRuleSegmentConvertResultLoadBalancers = actualMultipleRuleSegmentConvertResult.getLoadBalancers();
- assertThat(actualMultipleRuleSegmentConvertResultDataSources.size(), org.hamcrest.Matchers.is(expectedMultipleReadwriteSplittingRuleSegments.size()));
- assertThat(actualMultipleRuleSegmentConvertResultLoadBalancers.size(), org.hamcrest.Matchers.is(expectedMultipleReadwriteSplittingRuleSegments.size()));
- ReadwriteSplittingDataSourceRuleConfiguration[] actualRuleConfigurations = new ReadwriteSplittingDataSourceRuleConfiguration[expectedMultipleReadwriteSplittingRuleSegments.size()];
- actualMultipleRuleSegmentConvertResultDataSources.toArray(actualRuleConfigurations);
+ assertThat(actualMultipleRuleSegmentConvertResultDataSources.size(), is(expectedMultipleReadwriteSplittingRuleSegments.size()));
+ assertThat(actualMultipleRuleSegmentConvertResultLoadBalancers.size(), is(expectedMultipleReadwriteSplittingRuleSegments.size()));
+ List<ReadwriteSplittingDataSourceRuleConfiguration> actualRuleConfigurations = new ArrayList<>(actualMultipleRuleSegmentConvertResultDataSources);
Stream.iterate(0, i -> i + 1)
.limit(expectedMultipleReadwriteSplittingRuleSegments.size())
.forEach(i -> {
ReadwriteSplittingRuleSegment expectedReadwriteSplittingRuleSegment = expectedMultipleReadwriteSplittingRuleSegments.get(i);
- ReadwriteSplittingDataSourceRuleConfiguration actualRuleConfiguration = actualRuleConfigurations[i];
- assertThat(actualRuleConfiguration.getName(), org.hamcrest.Matchers.is(expectedReadwriteSplittingRuleSegment.getName()));
+ ReadwriteSplittingDataSourceRuleConfiguration actualRuleConfiguration = actualRuleConfigurations.get(i);
+ assertThat(actualRuleConfiguration.getName(), is(expectedReadwriteSplittingRuleSegment.getName()));
String expectedLoadBalancerName = String.format("%s_%s", expectedReadwriteSplittingRuleSegment.getName(), expectedReadwriteSplittingRuleSegment.getLoadBalancer());
- assertThat(actualRuleConfiguration.getLoadBalancerName(), org.hamcrest.Matchers.is(expectedLoadBalancerName));
- assertThat(actualRuleConfiguration.getWriteDataSourceName(), org.hamcrest.Matchers.is(expectedReadwriteSplittingRuleSegment.getWriteDataSource()));
+ assertThat(actualRuleConfiguration.getLoadBalancerName(), is(expectedLoadBalancerName));
+ assertThat(actualRuleConfiguration.getWriteDataSourceName(), is(expectedReadwriteSplittingRuleSegment.getWriteDataSource()));
assertThat(actualRuleConfiguration.getReadDataSourceNames(),
- org.hamcrest.Matchers.equalTo(expectedReadwriteSplittingRuleSegment.getReadDataSources() == null
+ equalTo(expectedReadwriteSplittingRuleSegment.getReadDataSources() == null
? Collections.emptyList()
: expectedReadwriteSplittingRuleSegment.getReadDataSources()));
- assertThat(actualMultipleRuleSegmentConvertResultLoadBalancers, org.hamcrest.Matchers.hasKey(expectedLoadBalancerName));
+ assertTrue(actualMultipleRuleSegmentConvertResultLoadBalancers.containsKey(expectedLoadBalancerName));
ShardingSphereAlgorithmConfiguration actualSphereAlgorithmConfiguration = actualMultipleRuleSegmentConvertResultLoadBalancers.get(actualRuleConfiguration.getLoadBalancerName());
- assertThat(actualSphereAlgorithmConfiguration.getType(), org.hamcrest.Matchers.containsString(expectedReadwriteSplittingRuleSegment.getLoadBalancer()));
- assertThat(actualSphereAlgorithmConfiguration.getProps(), org.hamcrest.Matchers.is(expectedReadwriteSplittingRuleSegment.getProps()));
+ assertThat(actualSphereAlgorithmConfiguration.getType(), containsString(expectedReadwriteSplittingRuleSegment.getLoadBalancer()));
+ assertThat(actualSphereAlgorithmConfiguration.getProps(), is(expectedReadwriteSplittingRuleSegment.getProps()));
});
}
-
+
private ReadwriteSplittingRuleSegment createReadwriteSplittingRuleSegment(final String name,
final String writeDataSource,
final List<String> readDataSourceList,
@@ -119,7 +109,7 @@ public final class ReadwriteSplittingRuleStatementConverterTest {
final Properties properties) {
return new ReadwriteSplittingRuleSegment(name, writeDataSource, readDataSourceList, loadBalancerTypeName, properties);
}
-
+
private ReadwriteSplittingRuleSegment createReadwriteSplittingRuleSegment(final String name,
final String autoAwareResource,
final String loadBalancer,