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 f361c515cd8 Add more test cases on ShadowExtractor (#33516)
f361c515cd8 is described below
commit f361c515cd8f9299651f891904c5d84655e48140
Author: Liang Zhang <[email protected]>
AuthorDate: Sun Nov 3 22:15:39 2024 +0800
Add more test cases on ShadowExtractor (#33516)
---
.../shadow/route/engine/util/ShadowExtractor.java | 26 +++----
.../ColumnRegexMatchedShadowAlgorithmTest.java | 2 +-
.../ColumnValueMatchedShadowAlgorithmTest.java | 2 +-
.../route/engine/util/ShadowExtractorTest.java | 81 ++++++++++++++++++++--
4 files changed, 91 insertions(+), 20 deletions(-)
diff --git
a/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/route/engine/util/ShadowExtractor.java
b/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/route/engine/util/ShadowExtractor.java
index ceff051be62..34a464268df 100644
---
a/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/route/engine/util/ShadowExtractor.java
+++
b/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/route/engine/util/ShadowExtractor.java
@@ -39,11 +39,11 @@ import java.util.Optional;
public final class ShadowExtractor {
/**
- * Get values in expression segment.
+ * Extract values.
*
* @param expression expression segment
* @param params parameters
- * @return values
+ * @return extracted values
*/
public static Optional<Collection<Comparable<?>>> extractValues(final
ExpressionSegment expression, final List<Object> params) {
Collection<Comparable<?>> result = new LinkedList<>();
@@ -54,33 +54,33 @@ public final class ShadowExtractor {
extractValues(((InExpression) expression).getRight(),
params).ifPresent(result::addAll);
}
if (expression instanceof ListExpression) {
- ((ListExpression) expression).getItems().forEach(each ->
extractValueInSimpleExpressionSegment(each, params).ifPresent(result::add));
+ ((ListExpression) expression).getItems().forEach(each ->
extractSimpleExpressionValue(each, params).ifPresent(result::add));
}
if (expression instanceof SimpleExpressionSegment) {
- extractValueInSimpleExpressionSegment(expression,
params).ifPresent(result::add);
+ extractSimpleExpressionValue(expression,
params).ifPresent(result::add);
}
return result.isEmpty() ? Optional.empty() : Optional.of(result);
}
- private static Optional<Comparable<?>>
extractValueInSimpleExpressionSegment(final ExpressionSegment expression, final
List<Object> params) {
+ private static Optional<Comparable<?>> extractSimpleExpressionValue(final
ExpressionSegment expression, final List<Object> params) {
if (expression instanceof LiteralExpressionSegment) {
- return
extractValueInLiteralExpressionSegment((LiteralExpressionSegment) expression);
+ return extractLiteralExpressionValue((LiteralExpressionSegment)
expression);
}
if (expression instanceof ParameterMarkerExpressionSegment) {
- return
extractValueInParameterMarkerExpressionSegment((ParameterMarkerExpressionSegment)
expression, params);
+ return
extractParameterMarkerExpressionValue((ParameterMarkerExpressionSegment)
expression, params);
}
return Optional.empty();
}
- private static Optional<Comparable<?>>
extractValueInParameterMarkerExpressionSegment(final
ParameterMarkerExpressionSegment expression, final List<Object> params) {
- return
castToComparable(params.get(expression.getParameterMarkerIndex()));
+ private static Optional<Comparable<?>> extractLiteralExpressionValue(final
LiteralExpressionSegment expression) {
+ return castToComparable(expression.getLiterals());
}
- private static Optional<Comparable<?>>
extractValueInLiteralExpressionSegment(final LiteralExpressionSegment
expression) {
- return castToComparable(expression.getLiterals());
+ private static Optional<Comparable<?>>
extractParameterMarkerExpressionValue(final ParameterMarkerExpressionSegment
expression, final List<Object> params) {
+ return
castToComparable(params.get(expression.getParameterMarkerIndex()));
}
- private static Optional<Comparable<?>> castToComparable(final Object
object) {
- return object instanceof Comparable<?> ? Optional.of((Comparable<?>)
object) : Optional.empty();
+ private static Optional<Comparable<?>> castToComparable(final Object
value) {
+ return value instanceof Comparable<?> ? Optional.of((Comparable<?>)
value) : Optional.empty();
}
}
diff --git
a/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/algorithm/shadow/column/ColumnRegexMatchedShadowAlgorithmTest.java
b/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/algorithm/shadow/column/ColumnRegexMatchedShadowAlgorithmTest.java
index 10558298d05..ef59de6effd 100644
---
a/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/algorithm/shadow/column/ColumnRegexMatchedShadowAlgorithmTest.java
+++
b/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/algorithm/shadow/column/ColumnRegexMatchedShadowAlgorithmTest.java
@@ -31,7 +31,7 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
class ColumnRegexMatchedShadowAlgorithmTest {
- private static final String SHADOW_TABLE = "t_user";
+ private static final String SHADOW_TABLE = "foo_tbl";
private static final String SHADOW_COLUMN = "shadow";
diff --git
a/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/algorithm/shadow/column/ColumnValueMatchedShadowAlgorithmTest.java
b/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/algorithm/shadow/column/ColumnValueMatchedShadowAlgorithmTest.java
index cc19d722cf3..d4c5c0a8a12 100644
---
a/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/algorithm/shadow/column/ColumnValueMatchedShadowAlgorithmTest.java
+++
b/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/algorithm/shadow/column/ColumnValueMatchedShadowAlgorithmTest.java
@@ -31,7 +31,7 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
class ColumnValueMatchedShadowAlgorithmTest {
- private static final String SHADOW_TABLE = "t_user";
+ private static final String SHADOW_TABLE = "foo_tbl";
private static final String SHADOW_COLUMN = "shadow";
diff --git
a/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/route/engine/util/ShadowExtractorTest.java
b/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/route/engine/util/ShadowExtractorTest.java
index 9022f7ab639..da0b789234e 100644
---
a/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/route/engine/util/ShadowExtractorTest.java
+++
b/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/route/engine/util/ShadowExtractorTest.java
@@ -17,24 +17,95 @@
package org.apache.shardingsphere.shadow.route.engine.util;
+import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.BinaryOperationExpression;
+import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ExpressionSegment;
+import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.InExpression;
+import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ListExpression;
import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.simple.LiteralExpressionSegment;
+import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.simple.ParameterMarkerExpressionSegment;
import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.simple.SimpleExpressionSegment;
+import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.subquery.SubqueryExpressionSegment;
import org.junit.jupiter.api.Test;
-import java.util.LinkedList;
+import java.util.Collection;
+import java.util.Collections;
import java.util.List;
+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.assertTrue;
class ShadowExtractorTest {
@Test
- void assertExtractValuesSimpleExpressionSegment() {
+ void assertExtractValuesWithBinaryOperationExpression() {
+ SimpleExpressionSegment leftSegment = new LiteralExpressionSegment(1,
2, "left");
+ SimpleExpressionSegment rightSegment = new LiteralExpressionSegment(1,
2, "right");
+ ExpressionSegment expressionSegment = new BinaryOperationExpression(1,
2, leftSegment, rightSegment, "=", "text");
+ Optional<Collection<Comparable<?>>> actual =
ShadowExtractor.extractValues(expressionSegment, Collections.emptyList());
+ assertTrue(actual.isPresent());
+ assertThat(actual.get().iterator().next(), is("right"));
+ }
+
+ @Test
+ void assertExtractValuesWithInExpression() {
+ SimpleExpressionSegment leftSegment = new LiteralExpressionSegment(1,
2, "left");
+ SimpleExpressionSegment rightSegment = new LiteralExpressionSegment(1,
2, "right");
+ ExpressionSegment expressionSegment = new InExpression(1, 2,
leftSegment, rightSegment, false);
+ Optional<Collection<Comparable<?>>> actual =
ShadowExtractor.extractValues(expressionSegment, Collections.emptyList());
+ assertTrue(actual.isPresent());
+ assertThat(actual.get().iterator().next(), is("right"));
+ }
+
+ @Test
+ void assertExtractValuesWithListExpression() {
+ SimpleExpressionSegment segment0 = new LiteralExpressionSegment(1, 2,
"expect0");
+ SimpleExpressionSegment segment1 = new LiteralExpressionSegment(1, 2,
"expect1");
+ ListExpression expressionSegment = new ListExpression(1, 2);
+ expressionSegment.getItems().add(segment0);
+ expressionSegment.getItems().add(segment1);
+ Optional<Collection<Comparable<?>>> actual =
ShadowExtractor.extractValues(expressionSegment, Collections.emptyList());
+ assertTrue(actual.isPresent());
+ assertThat(actual.get().iterator().next(), is("expect0"));
+ }
+
+ @Test
+ void assertExtractValuesWithLiteralExpressionSegment() {
SimpleExpressionSegment simpleExpressionSegment = new
LiteralExpressionSegment(1, 2, "expected");
- List<Object> params = new LinkedList<>();
- assertTrue(ShadowExtractor.extractValues(simpleExpressionSegment,
params).isPresent());
- assertThat(ShadowExtractor.extractValues(simpleExpressionSegment,
params).get().iterator().next(), is("expected"));
+ Optional<Collection<Comparable<?>>> actual =
ShadowExtractor.extractValues(simpleExpressionSegment, Collections.emptyList());
+ assertTrue(actual.isPresent());
+ assertThat(actual.get().iterator().next(), is("expected"));
+ }
+
+ @Test
+ void assertExtractValuesWithInvalidLiteralExpressionSegment() {
+ SimpleExpressionSegment simpleExpressionSegment = new
LiteralExpressionSegment(1, 2, new Object());
+ Optional<Collection<Comparable<?>>> actual =
ShadowExtractor.extractValues(simpleExpressionSegment, Collections.emptyList());
+ assertFalse(actual.isPresent());
+ }
+
+ @Test
+ void assertExtractValuesWithParameterMarkerExpressionSegment() {
+ SimpleExpressionSegment simpleExpressionSegment = new
ParameterMarkerExpressionSegment(1, 2, 0);
+ Optional<Collection<Comparable<?>>> actual =
ShadowExtractor.extractValues(simpleExpressionSegment,
Collections.singletonList(10));
+ assertTrue(actual.isPresent());
+ assertThat(actual.get().iterator().next(), is(10));
+ }
+
+ @Test
+ void assertExtractValuesWithInvalidParameterMarkerExpressionSegment() {
+ SimpleExpressionSegment simpleExpressionSegment = new
ParameterMarkerExpressionSegment(1, 2, 0);
+ Optional<Collection<Comparable<?>>> actual =
ShadowExtractor.extractValues(simpleExpressionSegment,
Collections.singletonList(new Object()));
+ assertFalse(actual.isPresent());
+ }
+
+ @Test
+ void assertExtractValuesWithSubqueryExpressionSegment() {
+ SimpleExpressionSegment simpleExpressionSegment = new
SubqueryExpressionSegment(null);
+ List<Object> params = Collections.singletonList(new Object());
+ Optional<Collection<Comparable<?>>> actual =
ShadowExtractor.extractValues(simpleExpressionSegment, params);
+ assertFalse(actual.isPresent());
}
}
