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 4b25322ddaa Add more test cases on EncryptShowCreateTableMergedResult
(#33607)
4b25322ddaa is described below
commit 4b25322ddaa044fd52b3140ce19dbb7a0f87c59c
Author: Liang Zhang <[email protected]>
AuthorDate: Sun Nov 10 20:59:09 2024 +0800
Add more test cases on EncryptShowCreateTableMergedResult (#33607)
* Add more test cases on EncryptShowCreateTableMergedResult
* Add more test cases on EncryptShowCreateTableMergedResult
* Add more test cases on EncryptShowCreateTableMergedResult
* Add more test cases on EncryptShowCreateTableMergedResult
* Add more test cases on EncryptShowCreateTableMergedResult
* Add more test cases on EncryptShowCreateTableMergedResult
* Add more test cases on EncryptShowCreateTableMergedResult
* Add more test cases on EncryptShowCreateTableMergedResult
* Add more test cases on EncryptShowCreateTableMergedResult
---
.../show/EncryptShowCreateTableMergedResult.java | 42 ++---
.../show/EncryptShowColumnsMergedResultTest.java | 33 ++--
.../EncryptShowCreateTableMergedResultTest.java | 175 ++++++++++++++-------
3 files changed, 157 insertions(+), 93 deletions(-)
diff --git
a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/merge/dal/show/EncryptShowCreateTableMergedResult.java
b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/merge/dal/show/EncryptShowCreateTableMergedResult.java
index 89de864862e..1b677fa9e75 100644
---
a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/merge/dal/show/EncryptShowCreateTableMergedResult.java
+++
b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/merge/dal/show/EncryptShowCreateTableMergedResult.java
@@ -59,7 +59,7 @@ public final class EncryptShowCreateTableMergedResult
implements MergedResult {
public EncryptShowCreateTableMergedResult(final RuleMetaData
globalRuleMetaData, final MergedResult mergedResult, final SQLStatementContext
sqlStatementContext, final EncryptRule rule) {
ShardingSpherePreconditions.checkState(sqlStatementContext instanceof
TableAvailable && 1 == ((TableAvailable)
sqlStatementContext).getTablesContext().getSimpleTables().size(),
- () -> new UnsupportedEncryptSQLException("SHOW CREATE TABLE
FOR MULTI TABLE"));
+ () -> new UnsupportedEncryptSQLException("SHOW CREATE TABLE
FOR MULTI TABLES"));
this.mergedResult = mergedResult;
tableName = ((TableAvailable)
sqlStatementContext).getTablesContext().getSimpleTables().iterator().next().getTableName().getIdentifier().getValue();
this.rule = rule;
@@ -73,37 +73,37 @@ public final class EncryptShowCreateTableMergedResult
implements MergedResult {
@Override
public Object getValue(final int columnIndex, final Class<?> type) throws
SQLException {
- if (CREATE_TABLE_DEFINITION_INDEX == columnIndex) {
- String result =
mergedResult.getValue(CREATE_TABLE_DEFINITION_INDEX, type).toString();
- Optional<EncryptTable> encryptTable =
rule.findEncryptTable(tableName);
- if (!encryptTable.isPresent() || !result.contains("(")) {
- return result;
- }
- CreateTableStatement createTableStatement = (CreateTableStatement)
sqlParserEngine.parse(result, false);
- List<ColumnDefinitionSegment> columnDefinitions = new
ArrayList<>(createTableStatement.getColumnDefinitions());
- StringBuilder builder = new StringBuilder(result.substring(0,
columnDefinitions.get(0).getStartIndex()));
- for (ColumnDefinitionSegment each : columnDefinitions) {
- findLogicColumnDefinition(each, encryptTable.get(),
result).ifPresent(optional -> builder.append(optional).append(COMMA));
- }
- // TODO decorate encrypt column index when we support index rewrite
- builder.delete(builder.length() - COMMA.length(),
builder.length()).append(result.substring(columnDefinitions.get(columnDefinitions.size()
- 1).getStopIndex() + 1));
- return builder.toString();
+ if (CREATE_TABLE_DEFINITION_INDEX != columnIndex) {
+ return mergedResult.getValue(columnIndex, type);
}
- return mergedResult.getValue(columnIndex, type);
+ String createTableSQL =
mergedResult.getValue(CREATE_TABLE_DEFINITION_INDEX, type).toString();
+ Optional<EncryptTable> encryptTable = rule.findEncryptTable(tableName);
+ if (!encryptTable.isPresent() || !createTableSQL.contains("(")) {
+ return createTableSQL;
+ }
+ CreateTableStatement createTableStatement = (CreateTableStatement)
sqlParserEngine.parse(createTableSQL, false);
+ List<ColumnDefinitionSegment> columnDefinitions = new
ArrayList<>(createTableStatement.getColumnDefinitions());
+ StringBuilder result = new StringBuilder(createTableSQL.substring(0,
columnDefinitions.get(0).getStartIndex()));
+ for (ColumnDefinitionSegment each : columnDefinitions) {
+ findLogicColumnDefinition(each, encryptTable.get(),
createTableSQL).ifPresent(optional -> result.append(optional).append(COMMA));
+ }
+ // TODO decorate encrypt column index when we support index rewrite
+ result.delete(result.length() - COMMA.length(),
result.length()).append(createTableSQL.substring(columnDefinitions.get(columnDefinitions.size()
- 1).getStopIndex() + 1));
+ return result.toString();
}
- private Optional<String> findLogicColumnDefinition(final
ColumnDefinitionSegment columnDefinition, final EncryptTable encryptTable,
final String sql) {
+ private Optional<String> findLogicColumnDefinition(final
ColumnDefinitionSegment columnDefinition, final EncryptTable encryptTable,
final String createTableSQL) {
ColumnSegment columnSegment = columnDefinition.getColumnName();
String columnName = columnSegment.getIdentifier().getValue();
if (encryptTable.isCipherColumn(columnName)) {
String logicColumn =
encryptTable.getLogicColumnByCipherColumn(columnName);
- return Optional.of(sql.substring(columnDefinition.getStartIndex(),
columnSegment.getStartIndex())
- +
columnSegment.getIdentifier().getQuoteCharacter().wrap(logicColumn) +
sql.substring(columnSegment.getStopIndex() + 1, columnDefinition.getStopIndex()
+ 1));
+ return
Optional.of(createTableSQL.substring(columnDefinition.getStartIndex(),
columnSegment.getStartIndex())
+ +
columnSegment.getIdentifier().getQuoteCharacter().wrap(logicColumn) +
createTableSQL.substring(columnSegment.getStopIndex() + 1,
columnDefinition.getStopIndex() + 1));
}
if (isDerivedColumn(encryptTable, columnName)) {
return Optional.empty();
}
- return Optional.of(sql.substring(columnDefinition.getStartIndex(),
columnDefinition.getStopIndex() + 1));
+ return
Optional.of(createTableSQL.substring(columnDefinition.getStartIndex(),
columnDefinition.getStopIndex() + 1));
}
private boolean isDerivedColumn(final EncryptTable encryptTable, final
String columnName) {
diff --git
a/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/merge/dal/show/EncryptShowColumnsMergedResultTest.java
b/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/merge/dal/show/EncryptShowColumnsMergedResultTest.java
index 46827d36337..888f3521783 100644
---
a/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/merge/dal/show/EncryptShowColumnsMergedResultTest.java
+++
b/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/merge/dal/show/EncryptShowColumnsMergedResultTest.java
@@ -71,35 +71,30 @@ class EncryptShowColumnsMergedResultTest {
}
@Test
- void assertNextWithNotHasNext() throws SQLException {
- assertFalse(createEncryptShowColumnsMergedResult(mergedResult,
mock(EncryptRule.class)).next());
- }
-
- @Test
- void assertNextWithHasNext() throws SQLException {
+ void assertNext() throws SQLException {
when(mergedResult.next()).thenReturn(true);
- assertTrue(createEncryptShowColumnsMergedResult(mergedResult,
mock(EncryptRule.class)).next());
+ assertTrue(createMergedResult(mergedResult,
mock(EncryptRule.class)).next());
}
@Test
void assertNextWithAssistedQuery() throws SQLException {
when(mergedResult.next()).thenReturn(true).thenReturn(false);
when(mergedResult.getValue(1,
String.class)).thenReturn("user_id_assisted");
- assertFalse(createEncryptShowColumnsMergedResult(mergedResult,
mockEncryptRule()).next());
+ assertFalse(createMergedResult(mergedResult,
mockEncryptRule()).next());
}
@Test
void assertNextWithLikeQuery() throws SQLException {
when(mergedResult.next()).thenReturn(true).thenReturn(false);
when(mergedResult.getValue(1,
String.class)).thenReturn("user_id_like");
- assertFalse(createEncryptShowColumnsMergedResult(mergedResult,
mockEncryptRule()).next());
+ assertFalse(createMergedResult(mergedResult,
mockEncryptRule()).next());
}
@Test
void assertNextWithLikeQueryAndMultiColumns() throws SQLException {
when(mergedResult.next()).thenReturn(true, true, true, false);
when(mergedResult.getValue(1,
String.class)).thenReturn("user_id_like", "order_id", "content");
- EncryptShowColumnsMergedResult actual =
createEncryptShowColumnsMergedResult(mergedResult, mockEncryptRule());
+ EncryptShowColumnsMergedResult actual =
createMergedResult(mergedResult, mockEncryptRule());
assertTrue(actual.next());
assertTrue(actual.next());
assertFalse(actual.next());
@@ -108,7 +103,7 @@ class EncryptShowColumnsMergedResultTest {
@Test
void assertGetValueWithCipherColumn() throws SQLException {
when(mergedResult.getValue(1,
String.class)).thenReturn("user_id_cipher");
- assertThat(createEncryptShowColumnsMergedResult(mergedResult,
mockEncryptRule()).getValue(1, String.class), is("user_id"));
+ assertThat(createMergedResult(mergedResult,
mockEncryptRule()).getValue(1, String.class), is("user_id"));
}
private EncryptRule mockEncryptRule() {
@@ -125,39 +120,39 @@ class EncryptShowColumnsMergedResultTest {
@Test
void assertGetValueWithOtherColumn() throws SQLException {
when(mergedResult.getValue(1,
String.class)).thenReturn("user_id_assisted");
- assertThat(createEncryptShowColumnsMergedResult(mergedResult,
mock(EncryptRule.class)).getValue(1, String.class), is("user_id_assisted"));
+ assertThat(createMergedResult(mergedResult,
mock(EncryptRule.class)).getValue(1, String.class), is("user_id_assisted"));
}
@Test
void assertGetValueWithOtherIndex() throws SQLException {
when(mergedResult.getValue(2, String.class)).thenReturn("order_id");
- assertThat(createEncryptShowColumnsMergedResult(mergedResult,
mock(EncryptRule.class)).getValue(2, String.class), is("order_id"));
+ assertThat(createMergedResult(mergedResult,
mock(EncryptRule.class)).getValue(2, String.class), is("order_id"));
}
@Test
void assertWasNull() throws SQLException {
- assertFalse(createEncryptShowColumnsMergedResult(mergedResult,
mock(EncryptRule.class)).wasNull());
+ assertFalse(createMergedResult(mergedResult,
mock(EncryptRule.class)).wasNull());
}
@Test
void assertGetCalendarValue() {
assertThrows(SQLFeatureNotSupportedException.class,
- () -> createEncryptShowColumnsMergedResult(mergedResult,
mock(EncryptRule.class)).getCalendarValue(1, Date.class,
Calendar.getInstance()));
+ () -> createMergedResult(mergedResult,
mock(EncryptRule.class)).getCalendarValue(1, Date.class,
Calendar.getInstance()));
}
@Test
void assertGetInputStream() {
- assertThrows(SQLFeatureNotSupportedException.class, () ->
createEncryptShowColumnsMergedResult(mergedResult,
mock(EncryptRule.class)).getInputStream(1, "asc"));
+ assertThrows(SQLFeatureNotSupportedException.class, () ->
createMergedResult(mergedResult, mock(EncryptRule.class)).getInputStream(1,
"asc"));
}
@Test
void assertGetCharacterStream() {
- assertThrows(SQLFeatureNotSupportedException.class, () ->
createEncryptShowColumnsMergedResult(mergedResult,
mock(EncryptRule.class)).getCharacterStream(1));
+ assertThrows(SQLFeatureNotSupportedException.class, () ->
createMergedResult(mergedResult,
mock(EncryptRule.class)).getCharacterStream(1));
}
- private EncryptShowColumnsMergedResult
createEncryptShowColumnsMergedResult(final MergedResult mergedResult, final
EncryptRule encryptRule) {
+ private EncryptShowColumnsMergedResult createMergedResult(final
MergedResult mergedResult, final EncryptRule rule) {
ShowColumnsStatementContext showColumnsStatementContext =
mock(ShowColumnsStatementContext.class, RETURNS_DEEP_STUBS);
when(showColumnsStatementContext.getTablesContext().getSimpleTables()).thenReturn(Collections.singleton(new
SimpleTableSegment(new TableNameSegment(0, 0, new
IdentifierValue("t_encrypt")))));
- return new EncryptShowColumnsMergedResult(mergedResult,
showColumnsStatementContext, encryptRule);
+ return new EncryptShowColumnsMergedResult(mergedResult,
showColumnsStatementContext, rule);
}
}
diff --git
a/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/merge/dal/show/EncryptShowCreateTableMergedResultTest.java
b/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/merge/dal/show/EncryptShowCreateTableMergedResultTest.java
index fbef912fe40..a87a7799bf0 100644
---
a/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/merge/dal/show/EncryptShowCreateTableMergedResultTest.java
+++
b/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/merge/dal/show/EncryptShowCreateTableMergedResultTest.java
@@ -20,9 +20,12 @@ package org.apache.shardingsphere.encrypt.merge.dal.show;
import
org.apache.shardingsphere.encrypt.config.rule.EncryptColumnItemRuleConfiguration;
import
org.apache.shardingsphere.encrypt.config.rule.EncryptColumnRuleConfiguration;
import
org.apache.shardingsphere.encrypt.config.rule.EncryptTableRuleConfiguration;
+import
org.apache.shardingsphere.encrypt.exception.syntax.UnsupportedEncryptSQLException;
import org.apache.shardingsphere.encrypt.rule.EncryptRule;
import org.apache.shardingsphere.encrypt.rule.table.EncryptTable;
+import
org.apache.shardingsphere.infra.binder.context.statement.SQLStatementContext;
import
org.apache.shardingsphere.infra.binder.context.statement.dal.ShowCreateTableStatementContext;
+import
org.apache.shardingsphere.infra.binder.context.statement.dml.SelectStatementContext;
import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
import org.apache.shardingsphere.infra.merge.result.MergedResult;
import org.apache.shardingsphere.infra.metadata.database.rule.RuleMetaData;
@@ -37,8 +40,13 @@ import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+import java.sql.Date;
import java.sql.SQLException;
+import java.sql.SQLFeatureNotSupportedException;
+import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedList;
@@ -47,82 +55,97 @@ 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.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
class EncryptShowCreateTableMergedResultTest {
+ private final DatabaseType databaseType =
TypedSPILoader.getService(DatabaseType.class, "MySQL");
+
@Mock
private MergedResult mergedResult;
@Test
- void assertNextWhenNextExist() throws SQLException {
- assertFalse(createEncryptShowCreateTableMergedResult(mergedResult,
mock(EncryptRule.class)).next());
+ void assertNewInstanceWithNotTableAvailableStatement() {
+ SQLStatementContext sqlStatementContext =
mock(SQLStatementContext.class);
+ assertThrows(UnsupportedEncryptSQLException.class, () -> new
EncryptShowCreateTableMergedResult(mock(RuleMetaData.class), mergedResult,
sqlStatementContext, mock(EncryptRule.class)));
+ }
+
+ @Test
+ void assertNewInstanceWithEmptyTable() {
+ SelectStatementContext sqlStatementContext =
mock(SelectStatementContext.class, RETURNS_DEEP_STUBS);
+
when(sqlStatementContext.getTablesContext().getSimpleTables()).thenReturn(Collections.emptyList());
+ assertThrows(UnsupportedEncryptSQLException.class, () -> new
EncryptShowCreateTableMergedResult(mock(RuleMetaData.class), mergedResult,
sqlStatementContext, mock(EncryptRule.class)));
}
@Test
- void assertNextWhenNextNotExist() throws SQLException {
+ void assertNext() throws SQLException {
when(mergedResult.next()).thenReturn(true);
- assertTrue(createEncryptShowCreateTableMergedResult(mergedResult,
mock(EncryptRule.class)).next());
+ assertTrue(createMergedResult(mergedResult, "foo_tbl",
mock(EncryptRule.class)).next());
}
@Test
- void assertGetValueWhenConfigFloatDataTypeAndComment() throws SQLException
{
- when(mergedResult.next()).thenReturn(true).thenReturn(false);
- when(mergedResult.getValue(2, String.class)).thenReturn(
- "CREATE TABLE `t_encrypt` (`id` INT NOT NULL, `user_id_cipher`
FLOAT(10, 2) NOT NULL "
- + "COMMENT ',123\\&/\\`\"abc', `order_id` VARCHAR(30)
NOT NULL, PRIMARY KEY (`id`)) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;");
+ void assertGetValueWithOtherColumnIndex() throws SQLException {
+ when(mergedResult.next()).thenReturn(true);
+ when(mergedResult.getValue(1, String.class)).thenReturn("foo_value");
+ EncryptShowCreateTableMergedResult actual =
createMergedResult(mergedResult, "foo_tbl",
mockEncryptRule(Collections.emptyList()));
+ assertTrue(actual.next());
+ assertThat(actual.getValue(1, String.class), is("foo_value"));
+ }
+
+ @Test
+ void assertGetValueWithFloatDataTypeAndComment() throws SQLException {
+ when(mergedResult.next()).thenReturn(true);
+ String actualSQL = "CREATE TABLE `foo_tbl` (`id` INT NOT NULL,
`user_id_cipher` FLOAT(10, 2) NOT NULL "
+ + "COMMENT ',123\\&/\\`\"abc', `order_id` VARCHAR(30) NOT
NULL, PRIMARY KEY (`id`)) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;";
+ when(mergedResult.getValue(2, String.class)).thenReturn(actualSQL);
EncryptColumnRuleConfiguration columnRuleConfig = new
EncryptColumnRuleConfiguration("user_id", new
EncryptColumnItemRuleConfiguration("user_id_cipher", "foo_encryptor"));
- EncryptShowCreateTableMergedResult actual =
createEncryptShowCreateTableMergedResult(mergedResult,
mockEncryptRule(Collections.singleton(columnRuleConfig)));
+ EncryptShowCreateTableMergedResult actual =
createMergedResult(mergedResult, "foo_tbl",
mockEncryptRule(Collections.singleton(columnRuleConfig)));
assertTrue(actual.next());
- assertThat(actual.getValue(2, String.class),
- is("CREATE TABLE `t_encrypt` (`id` INT NOT NULL, `user_id`
FLOAT(10, 2) NOT NULL "
- + "COMMENT ',123\\&/\\`\"abc', `order_id` VARCHAR(30)
NOT NULL, PRIMARY KEY (`id`)) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;"));
+ String expectedSQL = "CREATE TABLE `foo_tbl` (`id` INT NOT NULL,
`user_id` FLOAT(10, 2) NOT NULL "
+ + "COMMENT ',123\\&/\\`\"abc', `order_id` VARCHAR(30) NOT
NULL, PRIMARY KEY (`id`)) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;";
+ assertThat(actual.getValue(2, String.class), is(expectedSQL));
}
@Test
- void assertGetValueWhenConfigAssistedQueryColumn() throws SQLException {
- when(mergedResult.next()).thenReturn(true).thenReturn(false);
- when(mergedResult.getValue(2, String.class)).thenReturn(
- "CREATE TABLE `t_encrypt` (`id` INT NOT NULL, `user_id_cipher`
VARCHAR(100) NOT NULL, "
- + "`user_id_assisted` VARCHAR(100) NOT NULL,
`order_id` VARCHAR(30) NOT NULL, PRIMARY KEY (`id`)) ENGINE=InnoDB DEFAULT
CHARSET=utf8mb4;");
+ void assertGetValueWithAssistedQueryColumn() throws SQLException {
+ when(mergedResult.next()).thenReturn(true);
+ String actualSQL = "CREATE TABLE `foo_tbl` (`id` INT NOT NULL,
`user_id_cipher` VARCHAR(100) NOT NULL, "
+ + "`user_id_assisted` VARCHAR(100) NOT NULL, `order_id`
VARCHAR(30) NOT NULL, PRIMARY KEY (`id`)) ENGINE=InnoDB DEFAULT
CHARSET=utf8mb4;";
+ when(mergedResult.getValue(2, String.class)).thenReturn(actualSQL);
EncryptColumnRuleConfiguration columnRuleConfig = new
EncryptColumnRuleConfiguration("user_id", new
EncryptColumnItemRuleConfiguration("user_id_cipher", "foo_encryptor"));
columnRuleConfig.setAssistedQuery(new
EncryptColumnItemRuleConfiguration("user_id_assisted",
"foo_assist_query_encryptor"));
- EncryptShowCreateTableMergedResult actual =
createEncryptShowCreateTableMergedResult(mergedResult,
mockEncryptRule(Collections.singleton(columnRuleConfig)));
+ EncryptShowCreateTableMergedResult actual =
createMergedResult(mergedResult, "foo_tbl",
mockEncryptRule(Collections.singleton(columnRuleConfig)));
assertTrue(actual.next());
- assertThat(actual.getValue(2, String.class),
- is("CREATE TABLE `t_encrypt` (`id` INT NOT NULL, `user_id`
VARCHAR(100) NOT NULL, `order_id` VARCHAR(30) NOT NULL, PRIMARY KEY (`id`))
ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;"));
+ String expectedSQL = "CREATE TABLE `foo_tbl` (`id` INT NOT NULL,
`user_id` VARCHAR(100) NOT NULL, `order_id` VARCHAR(30) NOT NULL, PRIMARY KEY
(`id`)) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;";
+ assertThat(actual.getValue(2, String.class), is(expectedSQL));
}
@Test
- void assertGetValueWhenConfigLikeQueryColumn() throws SQLException {
- when(mergedResult.next()).thenReturn(true).thenReturn(false);
- when(mergedResult.getValue(2, String.class)).thenReturn("CREATE TABLE
`t_encrypt` (`id` INT NOT NULL, `user_id_cipher` VARCHAR(100) NOT NULL, "
- + "`user_id_like` VARCHAR(100) NOT NULL, `order_id`
VARCHAR(30) NOT NULL, PRIMARY KEY (`id`)) ENGINE=InnoDB DEFAULT
CHARSET=utf8mb4;");
+ void assertGetValueWithLikeQueryColumn() throws SQLException {
+ when(mergedResult.next()).thenReturn(true);
+ String actualSQL = "CREATE TABLE `foo_tbl` (`id` INT NOT NULL,
`user_id_cipher` VARCHAR(100) NOT NULL, "
+ + "`user_id_like` VARCHAR(100) NOT NULL, `order_id`
VARCHAR(30) NOT NULL, PRIMARY KEY (`id`)) ENGINE=InnoDB DEFAULT
CHARSET=utf8mb4;";
+ when(mergedResult.getValue(2, String.class)).thenReturn(actualSQL);
EncryptColumnRuleConfiguration columnRuleConfig = new
EncryptColumnRuleConfiguration("user_id", new
EncryptColumnItemRuleConfiguration("user_id_cipher", "foo_encryptor"));
columnRuleConfig.setLikeQuery(new
EncryptColumnItemRuleConfiguration("user_id_like", "foo_like_encryptor"));
- EncryptShowCreateTableMergedResult actual =
createEncryptShowCreateTableMergedResult(mergedResult,
mockEncryptRule(Collections.singleton(columnRuleConfig)));
+ EncryptShowCreateTableMergedResult actual =
createMergedResult(mergedResult, "foo_tbl",
mockEncryptRule(Collections.singleton(columnRuleConfig)));
assertTrue(actual.next());
- assertThat(actual.getValue(2, String.class),
- is("CREATE TABLE `t_encrypt` (`id` INT NOT NULL, `user_id`
VARCHAR(100) NOT NULL, `order_id` VARCHAR(30) NOT NULL, PRIMARY KEY (`id`))
ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;"));
- }
-
- private EncryptRule mockEncryptRule(final
Collection<EncryptColumnRuleConfiguration> encryptColumnRuleConfigs) {
- EncryptRule result = mock(EncryptRule.class);
- EncryptTable encryptTable = new EncryptTable(new
EncryptTableRuleConfiguration("t_encrypt", encryptColumnRuleConfigs),
Collections.emptyMap());
-
when(result.findEncryptTable("t_encrypt")).thenReturn(Optional.of(encryptTable));
- return result;
+ String expectedSQL = "CREATE TABLE `foo_tbl` (`id` INT NOT NULL,
`user_id` VARCHAR(100) NOT NULL, `order_id` VARCHAR(30) NOT NULL, PRIMARY KEY
(`id`)) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;";
+ assertThat(actual.getValue(2, String.class), is(expectedSQL));
}
@Test
- void assertGetValueWhenConfigMultiColumn() throws SQLException {
- when(mergedResult.next()).thenReturn(true).thenReturn(false);
- when(mergedResult.getValue(2, String.class)).thenReturn(
- "CREATE TABLE `t_encrypt` (`id` INT NOT NULL, `user_id_cipher`
VARCHAR(100) NOT NULL, `user_id_like` VARCHAR(100) NOT NULL, "
- + "`order_id_cipher` VARCHAR(30) NOT NULL,
`order_id_like` VARCHAR(30) NOT NULL, PRIMARY KEY (`id`)) ENGINE=InnoDB DEFAULT
CHARSET=utf8mb4;");
+ void assertGetValueWithMultiColumns() throws SQLException {
+ when(mergedResult.next()).thenReturn(true);
+ String actualSQL = "CREATE TABLE `foo_tbl` (`id` INT NOT NULL,
`user_id_cipher` VARCHAR(100) NOT NULL, `user_id_like` VARCHAR(100) NOT NULL, "
+ + "`order_id_cipher` VARCHAR(30) NOT NULL, `order_id_like`
VARCHAR(30) NOT NULL, PRIMARY KEY (`id`)) ENGINE=InnoDB DEFAULT
CHARSET=utf8mb4;";
+ when(mergedResult.getValue(2, String.class)).thenReturn(actualSQL);
Collection<EncryptColumnRuleConfiguration> columns = new
LinkedList<>();
EncryptColumnRuleConfiguration userIdColumnConfig = new
EncryptColumnRuleConfiguration("user_id", new
EncryptColumnItemRuleConfiguration("user_id_cipher", "foo_encryptor"));
userIdColumnConfig.setLikeQuery(new
EncryptColumnItemRuleConfiguration("user_id_like", "foo_like_encryptor"));
@@ -130,26 +153,72 @@ class EncryptShowCreateTableMergedResultTest {
EncryptColumnRuleConfiguration orderIdColumnConfig = new
EncryptColumnRuleConfiguration("order_id", new
EncryptColumnItemRuleConfiguration("order_id_cipher", "foo_encryptor"));
orderIdColumnConfig.setLikeQuery(new
EncryptColumnItemRuleConfiguration("order_id_like", "foo_like_encryptor"));
columns.add(orderIdColumnConfig);
- EncryptShowCreateTableMergedResult actual =
createEncryptShowCreateTableMergedResult(mergedResult,
mockEncryptRule(columns));
+ EncryptShowCreateTableMergedResult actual =
createMergedResult(mergedResult, "foo_tbl", mockEncryptRule(columns));
+ assertTrue(actual.next());
+ String expectedSQL = "CREATE TABLE `foo_tbl` (`id` INT NOT NULL,
`user_id` VARCHAR(100) NOT NULL, `order_id` VARCHAR(30) NOT NULL, PRIMARY KEY
(`id`)) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;";
+ assertThat(actual.getValue(2, String.class), is(expectedSQL));
+ }
+
+ @Test
+ void assertGetValueWithoutEncryptTable() throws SQLException {
+ when(mergedResult.next()).thenReturn(true);
+ String actualSQL = "CREATE TABLE `bar_tbl` (`id` INT NOT NULL,
`user_id_cipher` FLOAT(10, 2) NOT NULL "
+ + "COMMENT ',123\\&/\\`\"abc', `order_id` VARCHAR(30) NOT
NULL, PRIMARY KEY (`id`)) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;";
+ when(mergedResult.getValue(2, String.class)).thenReturn(actualSQL);
+ EncryptColumnRuleConfiguration columnRuleConfig = new
EncryptColumnRuleConfiguration("user_id", new
EncryptColumnItemRuleConfiguration("user_id_cipher", "foo_encryptor"));
+ EncryptShowCreateTableMergedResult actual =
createMergedResult(mergedResult, "bar_tbl",
mockEncryptRule(Collections.singleton(columnRuleConfig)));
assertTrue(actual.next());
- assertThat(actual.getValue(2, String.class),
- is("CREATE TABLE `t_encrypt` (`id` INT NOT NULL, `user_id`
VARCHAR(100) NOT NULL, `order_id` VARCHAR(30) NOT NULL, PRIMARY KEY (`id`))
ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;"));
+ String expectedSQL = "CREATE TABLE `bar_tbl` (`id` INT NOT NULL,
`user_id_cipher` FLOAT(10, 2) NOT NULL "
+ + "COMMENT ',123\\&/\\`\"abc', `order_id` VARCHAR(30) NOT
NULL, PRIMARY KEY (`id`)) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;";
+ assertThat(actual.getValue(2, String.class), is(expectedSQL));
+ }
+
+ @Test
+ void assertGetValueWithInvalidEncryptTable() throws SQLException {
+ when(mergedResult.next()).thenReturn(true);
+ when(mergedResult.getValue(2, String.class)).thenReturn("foo_tbl");
+ EncryptColumnRuleConfiguration columnRuleConfig = new
EncryptColumnRuleConfiguration("user_id", new
EncryptColumnItemRuleConfiguration("user_id_cipher", "foo_encryptor"));
+ EncryptShowCreateTableMergedResult actual =
createMergedResult(mergedResult, "foo_tbl",
mockEncryptRule(Collections.singleton(columnRuleConfig)));
+ assertTrue(actual.next());
+ assertThat(actual.getValue(2, String.class), is("foo_tbl"));
+ }
+
+ @Test
+ void assertGetCalendarValue() {
+ EncryptShowCreateTableMergedResult actual =
createMergedResult(mergedResult, "foo_tbl", mock(EncryptRule.class));
+ assertThrows(SQLFeatureNotSupportedException.class, () ->
actual.getCalendarValue(1, Date.class, Calendar.getInstance()));
+ }
+
+ @Test
+ void assertGetInputStream() {
+ EncryptShowCreateTableMergedResult actual =
createMergedResult(mergedResult, "foo_tbl", mock(EncryptRule.class));
+ assertThrows(SQLFeatureNotSupportedException.class, () ->
actual.getInputStream(1, "ascii"));
+ }
+
+ @Test
+ void assertGetCharacterStream() {
+ EncryptShowCreateTableMergedResult actual =
createMergedResult(mergedResult, "foo_tbl", mock(EncryptRule.class));
+ assertThrows(SQLFeatureNotSupportedException.class, () ->
actual.getCharacterStream(1));
}
@Test
void assertWasNull() throws SQLException {
- assertFalse(createEncryptShowCreateTableMergedResult(mergedResult,
mock(EncryptRule.class)).wasNull());
+ assertFalse(createMergedResult(mergedResult, "foo_tbl",
mock(EncryptRule.class)).wasNull());
}
- private EncryptShowCreateTableMergedResult
createEncryptShowCreateTableMergedResult(final MergedResult mergedResult, final
EncryptRule encryptRule) {
+ private EncryptShowCreateTableMergedResult createMergedResult(final
MergedResult mergedResult, final String tableName, final EncryptRule rule) {
ShowCreateTableStatementContext sqlStatementContext =
mock(ShowCreateTableStatementContext.class, RETURNS_DEEP_STUBS);
- IdentifierValue identifierValue = new IdentifierValue("t_encrypt");
- TableNameSegment tableNameSegment = new TableNameSegment(1, 4,
identifierValue);
- SimpleTableSegment simpleTableSegment = new
SimpleTableSegment(tableNameSegment);
-
when(sqlStatementContext.getTablesContext().getSimpleTables()).thenReturn(Collections.singleton(simpleTableSegment));
-
when(sqlStatementContext.getDatabaseType()).thenReturn(TypedSPILoader.getService(DatabaseType.class,
"MySQL"));
- RuleMetaData ruleMetaData = mock(RuleMetaData.class);
- when(ruleMetaData.getSingleRule(SQLParserRule.class)).thenReturn(new
SQLParserRule(new SQLParserRuleConfiguration(new CacheOption(128, 1024L), new
CacheOption(2000, 65535L))));
- return new EncryptShowCreateTableMergedResult(ruleMetaData,
mergedResult, sqlStatementContext, encryptRule);
+
when(sqlStatementContext.getTablesContext().getSimpleTables()).thenReturn(Collections.singleton(new
SimpleTableSegment(new TableNameSegment(1, 4, new
IdentifierValue(tableName)))));
+ when(sqlStatementContext.getDatabaseType()).thenReturn(databaseType);
+ RuleMetaData globalRuleMetaData = mock(RuleMetaData.class);
+
when(globalRuleMetaData.getSingleRule(SQLParserRule.class)).thenReturn(new
SQLParserRule(new SQLParserRuleConfiguration(new CacheOption(128, 1024L), new
CacheOption(2000, 65535L))));
+ return new EncryptShowCreateTableMergedResult(globalRuleMetaData,
mergedResult, sqlStatementContext, rule);
+ }
+
+ private EncryptRule mockEncryptRule(final
Collection<EncryptColumnRuleConfiguration> encryptColumnRuleConfigs) {
+ EncryptRule result = mock(EncryptRule.class);
+ EncryptTable encryptTable = new EncryptTable(new
EncryptTableRuleConfiguration("foo_tbl", encryptColumnRuleConfigs),
Collections.emptyMap());
+
when(result.findEncryptTable("foo_tbl")).thenReturn(Optional.of(encryptTable));
+ return result;
}
}
