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 7595b2a46e2 Upgrade junit 5 on HBase checker test (#24682)
7595b2a46e2 is described below
commit 7595b2a46e29e02ff6ab6b2870c1ff7e65840b93
Author: Liang Zhang <[email protected]>
AuthorDate: Mon Mar 20 13:46:23 2023 +0800
Upgrade junit 5 on HBase checker test (#24682)
---
...CommonHeterogeneousSQLStatementCheckerTest.java | 91 +++++---------
.../checker/HBaseDatabaseCheckerFactoryTest.java | 5 +-
.../HeterogeneousDeleteStatementCheckerTest.java | 50 +++-----
.../HeterogeneousInsertStatementCheckerTest.java | 53 +++-----
.../HeterogeneousSelectStatementCheckerTest.java | 138 +++++++--------------
.../HeterogeneousUpdateStatementCheckerTest.java | 56 +++------
6 files changed, 136 insertions(+), 257 deletions(-)
diff --git
a/proxy/backend/type/hbase/src/test/java/org/apache/shardingsphere/proxy/backend/hbase/checker/CommonHeterogeneousSQLStatementCheckerTest.java
b/proxy/backend/type/hbase/src/test/java/org/apache/shardingsphere/proxy/backend/hbase/checker/CommonHeterogeneousSQLStatementCheckerTest.java
index 8fd840fed38..088855da509 100644
---
a/proxy/backend/type/hbase/src/test/java/org/apache/shardingsphere/proxy/backend/hbase/checker/CommonHeterogeneousSQLStatementCheckerTest.java
+++
b/proxy/backend/type/hbase/src/test/java/org/apache/shardingsphere/proxy/backend/hbase/checker/CommonHeterogeneousSQLStatementCheckerTest.java
@@ -22,115 +22,80 @@ import
org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.BetweenE
import
org.apache.shardingsphere.sql.parser.sql.common.segment.dml.predicate.WhereSegment;
import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
import
org.apache.shardingsphere.sql.parser.sql.common.statement.dml.SelectStatement;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+
import java.util.Optional;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+
+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.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
public final class CommonHeterogeneousSQLStatementCheckerTest {
@Test
public void assertIsSinglePoint() {
SelectStatement sqlStatement = (SelectStatement)
HBaseSupportedSQLStatement.parseSQLStatement("select /*+ hbase */ * from
t_order where rowKey = '1'");
- CommonHeterogeneousSQLStatementChecker<SQLStatement>
commonHeterogeneousSQLStatementChecker = new
CommonHeterogeneousSQLStatementChecker<>(sqlStatement);
-
commonHeterogeneousSQLStatementChecker.checkIsSinglePointQuery(sqlStatement.getWhere());
+ new
CommonHeterogeneousSQLStatementChecker<>(sqlStatement).checkIsSinglePointQuery(sqlStatement.getWhere());
}
@Test
public void assertIsSinglePointWithErrorKey() {
SelectStatement sqlStatement = (SelectStatement)
HBaseSupportedSQLStatement.parseSQLStatement("select /*+ hbase */ * from
t_order where a = '1'");
- CommonHeterogeneousSQLStatementChecker<SQLStatement>
commonHeterogeneousSQLStatementChecker = new
CommonHeterogeneousSQLStatementChecker<>(sqlStatement);
- try {
-
commonHeterogeneousSQLStatementChecker.checkIsSinglePointQuery(sqlStatement.getWhere());
- fail();
- } catch (IllegalArgumentException e) {
- assertEquals(e.getMessage(), "a is not a allowed key");
- }
+ Exception ex = assertThrows(IllegalArgumentException.class, () -> new
CommonHeterogeneousSQLStatementChecker<>(sqlStatement).checkIsSinglePointQuery(sqlStatement.getWhere()));
+ assertThat(ex.getMessage(), is("a is not a allowed key"));
}
@Test
public void assertIsSinglePointWithErrorOperation() {
SelectStatement sqlStatement = (SelectStatement)
HBaseSupportedSQLStatement.parseSQLStatement("select /*+ hbase */ * from
t_order where rowKey between '1' and '2' ");
- CommonHeterogeneousSQLStatementChecker<SQLStatement>
commonHeterogeneousSQLStatementChecker = new
CommonHeterogeneousSQLStatementChecker<>(sqlStatement);
- try {
-
commonHeterogeneousSQLStatementChecker.checkIsSinglePointQuery(sqlStatement.getWhere());
- fail();
- } catch (IllegalArgumentException e) {
- assertEquals(e.getMessage(), "Only Support
BinaryOperationExpression");
- }
+ Exception ex = assertThrows(IllegalArgumentException.class, () -> new
CommonHeterogeneousSQLStatementChecker<>(sqlStatement).checkIsSinglePointQuery(sqlStatement.getWhere()));
+ assertThat(ex.getMessage(), is("Only Support
BinaryOperationExpression"));
}
@Test
public void assertInExpression() {
SelectStatement sqlStatement = (SelectStatement)
HBaseSupportedSQLStatement.parseSQLStatement("select /*+ hbase */ * from
t_order where rowKey in ('1', '2') ");
- CommonHeterogeneousSQLStatementChecker<SQLStatement>
commonHeterogeneousSQLStatementChecker = new
CommonHeterogeneousSQLStatementChecker<>(sqlStatement);
Optional<WhereSegment> whereSegment = sqlStatement.getWhere();
- if (whereSegment.isPresent()) {
-
commonHeterogeneousSQLStatementChecker.checkInExpressionIsExpected(whereSegment.get().getExpr());
- } else {
- fail();
- }
+ assertTrue(whereSegment.isPresent());
+ new
CommonHeterogeneousSQLStatementChecker<>(sqlStatement).checkInExpressionIsExpected(whereSegment.get().getExpr());
}
@Test
public void assertInExpressionWithNotIn() {
SelectStatement sqlStatement = (SelectStatement)
HBaseSupportedSQLStatement.parseSQLStatement("select /*+ hbase */ * from
t_order where rowKey not in ('1', '2') ");
- CommonHeterogeneousSQLStatementChecker<SQLStatement>
commonHeterogeneousSQLStatementChecker = new
CommonHeterogeneousSQLStatementChecker<>(sqlStatement);
Optional<WhereSegment> whereSegment = sqlStatement.getWhere();
- if (whereSegment.isPresent()) {
- try {
-
commonHeterogeneousSQLStatementChecker.checkInExpressionIsExpected(whereSegment.get().getExpr());
- fail();
- } catch (IllegalArgumentException e) {
- assertEquals(e.getMessage(), "Do not supported `not in`");
- }
- } else {
- fail();
- }
+ assertTrue(whereSegment.isPresent());
+ Exception ex = assertThrows(IllegalArgumentException.class, () -> new
CommonHeterogeneousSQLStatementChecker<>(sqlStatement).checkInExpressionIsExpected(whereSegment.get().getExpr()));
+ assertThat(ex.getMessage(), is("Do not supported `not in`"));
}
@Test
public void assertInExpressionWithErrorKey() {
SelectStatement sqlStatement = (SelectStatement)
HBaseSupportedSQLStatement.parseSQLStatement("select /*+ hbase */ * from
t_order where a in ('1', '2') ");
- CommonHeterogeneousSQLStatementChecker<SQLStatement>
commonHeterogeneousSQLStatementChecker = new
CommonHeterogeneousSQLStatementChecker<>(sqlStatement);
Optional<WhereSegment> whereSegment = sqlStatement.getWhere();
- if (whereSegment.isPresent()) {
- try {
-
commonHeterogeneousSQLStatementChecker.checkInExpressionIsExpected(whereSegment.get().getExpr());
- fail();
- } catch (IllegalArgumentException e) {
- assertEquals(e.getMessage(), "a is not a allowed key");
- }
- } else {
- fail();
- }
+ assertTrue(whereSegment.isPresent());
+ Exception ex = assertThrows(IllegalArgumentException.class, () -> new
CommonHeterogeneousSQLStatementChecker<>(sqlStatement).checkInExpressionIsExpected(whereSegment.get().getExpr()));
+ assertThat(ex.getMessage(), is("a is not a allowed key"));
}
@Test
public void assertIsAllowExpressionSegment() {
SelectStatement sqlStatement = (SelectStatement)
HBaseSupportedSQLStatement.parseSQLStatement("select /*+ hbase */ * from
t_order where rowKey BETWEEN 'v1' AND 'v2' ");
- CommonHeterogeneousSQLStatementChecker<SQLStatement>
commonHeterogeneousSQLStatementChecker = new
CommonHeterogeneousSQLStatementChecker<>(sqlStatement);
Optional<WhereSegment> whereSegment = sqlStatement.getWhere();
- if (whereSegment.isPresent()) {
- BetweenExpression betweenExpression = (BetweenExpression)
whereSegment.get().getExpr();
-
assertTrue(commonHeterogeneousSQLStatementChecker.isAllowExpressionSegment(betweenExpression.getBetweenExpr()));
-
assertTrue(commonHeterogeneousSQLStatementChecker.isAllowExpressionSegment(betweenExpression.getAndExpr()));
- } else {
- fail();
- }
+ assertTrue(whereSegment.isPresent());
+ BetweenExpression betweenExpression = (BetweenExpression)
whereSegment.get().getExpr();
+ CommonHeterogeneousSQLStatementChecker<SQLStatement>
commonHeterogeneousSQLStatementChecker = new
CommonHeterogeneousSQLStatementChecker<>(sqlStatement);
+
assertTrue(commonHeterogeneousSQLStatementChecker.isAllowExpressionSegment(betweenExpression.getBetweenExpr()));
+
assertTrue(commonHeterogeneousSQLStatementChecker.isAllowExpressionSegment(betweenExpression.getAndExpr()));
}
@Test
public void assertIsAllowExpressionSegmentError() {
SelectStatement sqlStatement = (SelectStatement)
HBaseSupportedSQLStatement.parseSQLStatement("select /*+ hbase */ * from
t_order where rowKey = '1'");
- CommonHeterogeneousSQLStatementChecker<SQLStatement>
commonHeterogeneousSQLStatementChecker = new
CommonHeterogeneousSQLStatementChecker<>(sqlStatement);
Optional<WhereSegment> whereSegment = sqlStatement.getWhere();
- if (whereSegment.isPresent()) {
-
assertFalse(commonHeterogeneousSQLStatementChecker.isAllowExpressionSegment(whereSegment.get().getExpr()));
- } else {
- fail();
- }
+ assertTrue(whereSegment.isPresent());
+ assertFalse(new
CommonHeterogeneousSQLStatementChecker<>(sqlStatement).isAllowExpressionSegment(whereSegment.get().getExpr()));
}
}
diff --git
a/proxy/backend/type/hbase/src/test/java/org/apache/shardingsphere/proxy/backend/hbase/checker/HBaseDatabaseCheckerFactoryTest.java
b/proxy/backend/type/hbase/src/test/java/org/apache/shardingsphere/proxy/backend/hbase/checker/HBaseDatabaseCheckerFactoryTest.java
index 8984f1c45f4..0248c871c7c 100644
---
a/proxy/backend/type/hbase/src/test/java/org/apache/shardingsphere/proxy/backend/hbase/checker/HBaseDatabaseCheckerFactoryTest.java
+++
b/proxy/backend/type/hbase/src/test/java/org/apache/shardingsphere/proxy/backend/hbase/checker/HBaseDatabaseCheckerFactoryTest.java
@@ -23,10 +23,11 @@ import
org.apache.shardingsphere.sql.parser.sql.dialect.statement.mysql.dml.MySQ
import
org.apache.shardingsphere.sql.parser.sql.dialect.statement.mysql.dml.MySQLInsertStatement;
import
org.apache.shardingsphere.sql.parser.sql.dialect.statement.mysql.dml.MySQLSelectStatement;
import
org.apache.shardingsphere.sql.parser.sql.dialect.statement.mysql.dml.MySQLUpdateStatement;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.mockito.Mockito.mock;
public final class HBaseDatabaseCheckerFactoryTest {
diff --git
a/proxy/backend/type/hbase/src/test/java/org/apache/shardingsphere/proxy/backend/hbase/checker/HeterogeneousDeleteStatementCheckerTest.java
b/proxy/backend/type/hbase/src/test/java/org/apache/shardingsphere/proxy/backend/hbase/checker/HeterogeneousDeleteStatementCheckerTest.java
index ee5bc56379a..c9d7b7e8bdf 100644
---
a/proxy/backend/type/hbase/src/test/java/org/apache/shardingsphere/proxy/backend/hbase/checker/HeterogeneousDeleteStatementCheckerTest.java
+++
b/proxy/backend/type/hbase/src/test/java/org/apache/shardingsphere/proxy/backend/hbase/checker/HeterogeneousDeleteStatementCheckerTest.java
@@ -19,79 +19,65 @@ package
org.apache.shardingsphere.proxy.backend.hbase.checker;
import
org.apache.shardingsphere.proxy.backend.hbase.result.HBaseSupportedSQLStatement;
import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
+import org.junit.jupiter.api.Test;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
public final class HeterogeneousDeleteStatementCheckerTest {
- @Rule
- public ExpectedException expectedEx = ExpectedException.none();
-
@Test
public void assertExecuteDeleteStatement() {
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(HBaseSupportedSQLStatement.getDeleteStatement());
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ HBaseCheckerFactory.newInstance(sqlStatement).execute();
}
@Test
public void assertOperatorIsNotEqual() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("Only Supported `=` operator");
String sql = "delete /*+ hbase */ from t_test_order where rowKey > 1";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("Only Supported `=` operator"));
}
@Test
public void assertColumnIsNotRowKey() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("is not a allowed key");
String sql = "delete /*+ hbase */ from t_test_order where age = 1";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("age is not a allowed key"));
}
@Test
public void assertLeftIsNotColumn() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("left segment must is ColumnSegment");
String sql = "delete /*+ hbase */ from t_test_order where 1 = 1";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("left segment must is ColumnSegment"));
}
@Test
public void assertMultiExpression() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("Do not supported Multiple expressions");
String sql = "DELETE /*+ hbase */ FROM t_order WHERE order_id = ? AND
user_id = ? AND status=?";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("Do not supported Multiple
expressions"));
}
@Test
public void assertWithBetweenExpression() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("Only Support BinaryOperationExpression");
String sql = "DELETE /*+ hbase */ FROM t_order WHERE rowKey between 1
and 5";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("Only Support
BinaryOperationExpression"));
}
@Test
public void assertNotWhereSegment() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("Must Have Where Segment");
String sql = "DELETE /*+ hbase */ FROM t_order";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("Must Have Where Segment"));
}
}
diff --git
a/proxy/backend/type/hbase/src/test/java/org/apache/shardingsphere/proxy/backend/hbase/checker/HeterogeneousInsertStatementCheckerTest.java
b/proxy/backend/type/hbase/src/test/java/org/apache/shardingsphere/proxy/backend/hbase/checker/HeterogeneousInsertStatementCheckerTest.java
index 543ded8e1b9..384f1d0d1c9 100644
---
a/proxy/backend/type/hbase/src/test/java/org/apache/shardingsphere/proxy/backend/hbase/checker/HeterogeneousInsertStatementCheckerTest.java
+++
b/proxy/backend/type/hbase/src/test/java/org/apache/shardingsphere/proxy/backend/hbase/checker/HeterogeneousInsertStatementCheckerTest.java
@@ -19,87 +19,72 @@ package
org.apache.shardingsphere.proxy.backend.hbase.checker;
import
org.apache.shardingsphere.proxy.backend.hbase.result.HBaseSupportedSQLStatement;
import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
+import org.junit.jupiter.api.Test;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
public final class HeterogeneousInsertStatementCheckerTest {
- @Rule
- public ExpectedException expectedEx = ExpectedException.none();
-
@Test
public void assertExecuteInsertStatement() {
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(HBaseSupportedSQLStatement.getInsertStatement());
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ HBaseCheckerFactory.newInstance(sqlStatement).execute();
}
@Test
public void assertInsertWithoutRowKey() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("First column must be rowKey");
String sql = "INSERT /*+ HBase */ INTO t_order (order_id, user_id,
status) VALUES (?, ?, ?)";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("First column must be rowKey"));
}
@Test
public void assertInsertWithoutColumns() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("The inserted column must be explicitly
specified");
String sql = "INSERT /*+ HBase */ INTO t_order VALUES (?, ?, ?)";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("The inserted column must be explicitly
specified"));
}
@Test
public void assertInsertWithMultipleRowKey() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("Cannot contain multiple rowKey");
String sql = "INSERT /*+ HBase */ INTO t_order (rowKey, id, status)
VALUES (?, ?, ?)";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("Cannot contain multiple rowKey"));
}
@Test
public void assertInsertWithOnDuplicateKey() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("Do not supported ON DUPLICATE KEY UPDATE");
String sql = "INSERT /*+ HBase */ INTO t_order (rowKey, user_id,
status) VALUES (?, ?, ?) ON DUPLICATE KEY UPDATE status = ?";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("Do not supported ON DUPLICATE KEY
UPDATE"));
}
@Test
public void assertInsertWithFunction() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("Value must is literal or parameter marker");
String sql = "INSERT /*+ HBase */ INTO t_order_item (rowKey, order_id,
user_id, status, creation_date) VALUES (?, ?, ?, 'insert', now())";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("Value must is literal or parameter
marker"));
}
@Test
public void assertInsertWithLiteralAndParameterMarker() {
String sql = "INSERT /*+ HBase */ INTO t_order_item(rowKey, order_id,
user_id, status, creation_date) VALUES (?, ?, ?, 'insert', '2017-08-08')";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ HBaseCheckerFactory.newInstance(sqlStatement).execute();
}
@Test
public void assertInsertWithSubQuery() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("Do not supported `insert into...select...`");
String sql = "INSERT /*+ HBase */ INTO t_order_item(rowKey, order_id,
user_id) select rowKey, order_id, user_id from t_order";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("Do not supported `insert
into...select...`"));
}
}
diff --git
a/proxy/backend/type/hbase/src/test/java/org/apache/shardingsphere/proxy/backend/hbase/checker/HeterogeneousSelectStatementCheckerTest.java
b/proxy/backend/type/hbase/src/test/java/org/apache/shardingsphere/proxy/backend/hbase/checker/HeterogeneousSelectStatementCheckerTest.java
index 44ba3fbb630..a57ef12600d 100644
---
a/proxy/backend/type/hbase/src/test/java/org/apache/shardingsphere/proxy/backend/hbase/checker/HeterogeneousSelectStatementCheckerTest.java
+++
b/proxy/backend/type/hbase/src/test/java/org/apache/shardingsphere/proxy/backend/hbase/checker/HeterogeneousSelectStatementCheckerTest.java
@@ -22,19 +22,18 @@ import
org.apache.shardingsphere.proxy.backend.hbase.props.HBaseProperties;
import org.apache.shardingsphere.proxy.backend.hbase.props.HBasePropertyKey;
import
org.apache.shardingsphere.proxy.backend.hbase.result.HBaseSupportedSQLStatement;
import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public final class HeterogeneousSelectStatementCheckerTest {
- @Rule
- public ExpectedException expectedEx = ExpectedException.none();
-
- @Before
+ @BeforeEach
public void setUp() {
HBaseProperties props = mock(HBaseProperties.class);
when(props.getValue(HBasePropertyKey.MAX_SCAN_LIMIT_SIZE)).thenReturn(5000L);
@@ -44,216 +43,175 @@ public final class
HeterogeneousSelectStatementCheckerTest {
@Test
public void assertSelectStatement() {
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(HBaseSupportedSQLStatement.getSelectStatement());
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ HBaseCheckerFactory.newInstance(sqlStatement).execute();
}
@Test
public void assertSelectStatementWithLargeRowCount() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("row count must less than 5000");
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement("select /*+ hbase */ * from
t_order where id = 1 limit 5001");
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("row count must less than 5000"));
}
@Test
public void assertSelectStatementWithLimitSegment() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("Do not supported offset segment");
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement("select /*+ hbase */ * from
t_order where id = 1 limit 5 offset 3");
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("Do not supported offset segment"));
}
@Test
public void assertSelectStatementWithLockSegment() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("Do not supported lock segment");
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement("select /*+ hbase */ * from
t_order where id = 1 lock in share mode");
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("Do not supported lock segment"));
}
@Test
public void assertSelectStatementWithFunction() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("Only supported ShorthandProjection and
ColumnProjection");
String sql = "SELECT /*+ HBase */ sum(score) FROM person";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("Only supported ShorthandProjection and
ColumnProjection and crc32ExpressionProjection"));
}
@Test
public void assertSelectStatementWithJoinStatement() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("Only supported SimpleTableSegment");
String sql = "SELECT /*+ HBase */ * FROM t_order o JOIN t_order_item i
ON o.user_id = i.user_id AND o.order_id = i.order_id";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("Only supported SimpleTableSegment"));
}
@Test
public void assertSelectStatementWithMultipleInExpression() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("left segment must is ColumnSegment");
String sql = "SELECT /*+ HBase */ * FROM t_order WHERE rowKey IN (?,
?) AND id IN (?, ?)";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("left segment must is ColumnSegment"));
}
@Test
public void assertSelectStatementWithInExpression() {
String sql = "SELECT /*+ HBase */ * from t_order where rowKey in (1,
2, 3)";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ HBaseCheckerFactory.newInstance(sqlStatement).execute();
}
@Test
public void assertSelectStatementWithErrorKey() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("age is not a allowed key");
String sql = "SELECT /*+ HBase */ * from t_order where age in (1, 2,
3)";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("age is not a allowed key"));
}
@Test
public void assertExecuteSelectWithNotIn() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("Do not supported `not in`");
String sql = "SELECT /*+ HBase */ * from t_order where rowKey not in
(1, 2, 3)";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("Do not supported `not in`"));
}
@Test
public void assertExecuteSelectWithParameterMarker() {
String sql = "SELECT /*+ HBase */ * from t_order where rowKey in (?,
?, ?)";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ HBaseCheckerFactory.newInstance(sqlStatement).execute();
}
@Test
public void assertSelectStatementUseCrc32() {
String sql = "SELECT /*+ HBase */ crc32(concat_ws('#',rowKey)) from
t_order where rowKey in (1, 2, 3)";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ HBaseCheckerFactory.newInstance(sqlStatement).execute();
}
@Test
public void assertExecuteSelectWithErrorInExpression() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("Only supported ListExpression");
String sql = "SELECT /*+ HBase */ * from t_order where rowKey in
(select rowKey from t_order_item)";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("Only supported ListExpression"));
}
@Test
public void assertExecuteSelectWithBetween() {
String sql = "SELECT /*+ HBase */ * from t_order where rowKey between
1 and 2";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ HBaseCheckerFactory.newInstance(sqlStatement).execute();
}
@Test
public void assertExecuteSelectWithNotBetween() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("Do not supported `not between...and...`");
String sql = "SELECT /*+ HBase */ * from t_order where rowKey not
between 1 and 2";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("Do not supported `not
between...and...`"));
}
@Test
public void assertExecuteSelectWithBetweenErrorKey() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("age is not a allowed key");
String sql = "SELECT /*+ HBase */ * from t_order where age between 1
and 2";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("age is not a allowed key"));
}
@Test
public void assertExecuteSelectWithErrorBetweenExpr() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("between expr must is literal or parameter
marker");
String sql = "SELECT /*+ HBase */ * from t_order where rowKey between
1 and now()";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("between expr must is literal or
parameter marker"));
}
@Test
public void assertSelectWithGroupBy() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("Do not supported group by segment");
String sql = "SELECT /*+ HBase */ * from t_order group by order_id";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("Do not supported group by segment"));
}
@Test
public void assertSelectWithNotAllowOperator() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("Only Supported `=` operator");
String sql = "select /*+ hbase */ * from t_order where rowKey != 1";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("Only Supported `=` operator"));
}
@Test
public void assertSelectWithNotAllowColumn() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("age is not a allowed key");
String sql = "select /*+ hbase */ * from t_order where age = 1";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("age is not a allowed key"));
}
@Test
public void assertSelectWithMultipleExpression() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("Do not supported Multiple expressions");
String sql = "select /*+ hbase */ * from t_order where rowKey = 1 and
age = 2";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("Do not supported Multiple
expressions"));
}
@Test
public void assertSelectWithNotColumnExpression() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("left segment must is ColumnSegment");
String sql = "select /*+ hbase */ * from t_order where 1 = 1";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("left segment must is ColumnSegment"));
}
@Test
public void assertSelectWithParameterMarker() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("Only supported ShorthandProjection and
ColumnProjection");
String sql = "select /*+ hbase */ rowKey, name, ? from t_order where
rowKey = 'kid'";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("Only supported ShorthandProjection and
ColumnProjection and crc32ExpressionProjection"));
}
}
diff --git
a/proxy/backend/type/hbase/src/test/java/org/apache/shardingsphere/proxy/backend/hbase/checker/HeterogeneousUpdateStatementCheckerTest.java
b/proxy/backend/type/hbase/src/test/java/org/apache/shardingsphere/proxy/backend/hbase/checker/HeterogeneousUpdateStatementCheckerTest.java
index 0ac5d34ebeb..34d24ce818d 100644
---
a/proxy/backend/type/hbase/src/test/java/org/apache/shardingsphere/proxy/backend/hbase/checker/HeterogeneousUpdateStatementCheckerTest.java
+++
b/proxy/backend/type/hbase/src/test/java/org/apache/shardingsphere/proxy/backend/hbase/checker/HeterogeneousUpdateStatementCheckerTest.java
@@ -19,89 +19,73 @@ package
org.apache.shardingsphere.proxy.backend.hbase.checker;
import
org.apache.shardingsphere.proxy.backend.hbase.result.HBaseSupportedSQLStatement;
import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
+import org.junit.jupiter.api.Test;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
public final class HeterogeneousUpdateStatementCheckerTest {
- @Rule
- public ExpectedException expectedEx = ExpectedException.none();
-
@Test
public void assertExecuteUpdateStatement() {
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(HBaseSupportedSQLStatement.getUpdateStatement());
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ HBaseCheckerFactory.newInstance(sqlStatement).execute();
}
@Test
public void assertUpdateWithFunction() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("Assigment must is literal or parameter
marker");
String sql = "update /*+ hbase */ t_test_order set age = 10, name =
'bob', time = now() where rowKey = 1";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("Assigment must is literal or parameter
marker"));
}
@Test
public void assertOperatorIsNotEqual() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("Only Supported `=` operator");
String sql = "update /*+ hbase */ t_test_order set age = 10 where
rowKey > 1";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("Only Supported `=` operator"));
}
@Test
public void assertColumnIsNotRowKey() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("is not a allowed key");
String sql = "update /*+ hbase */ t_test_order set age = 10 where age
= 1";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("age is not a allowed key"));
}
@Test
public void assertLeftIsNotColumn() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("left segment must is ColumnSegment");
String sql = "update /*+ hbase */ t_test_order set age = 10 where 1 =
1";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("left segment must is ColumnSegment"));
}
@Test
public void assertMultiExpression() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("Do not supported Multiple expressions");
String sql = "update /*+ hbase */ t_test_order set age = 10 WHERE
order_id = ? AND user_id = ? AND status=?";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("Do not supported Multiple
expressions"));
}
@Test
public void assertNotWhereSegment() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("Must Have Where Segment");
String sql = "update /*+ hbase */ t_test_order set age = 10 ";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("Must Have Where Segment"));
}
@Test
public void assertUpdateRowKey() {
- expectedEx.expect(IllegalArgumentException.class);
- expectedEx.expectMessage("Do not allow update rowKey");
String sql = "update /*+ hbase */ t_test_order set rowKey = 10 where
rowKey = 'kid'";
SQLStatement sqlStatement =
HBaseSupportedSQLStatement.parseSQLStatement(sql);
- HeterogeneousSQLStatementChecker<?> actual =
HBaseCheckerFactory.newInstance(sqlStatement);
- actual.execute();
+ Exception ex = assertThrows(IllegalArgumentException.class, () ->
HBaseCheckerFactory.newInstance(sqlStatement).execute());
+ assertThat(ex.getMessage(), is("Do not allow update rowKey"));
}
}
