You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by zh...@apache.org on 2024/11/10 14:03:23 UTC
(shardingsphere) branch master updated: Add more test cases on EncryptShowCreateTableMergedResult (#33609)
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 d1aed3d994f Add more test cases on EncryptShowCreateTableMergedResult (#33609)
d1aed3d994f is described below
commit d1aed3d994f2d2d5bab7114154a96c34da644316
Author: Liang Zhang <zh...@apache.org>
AuthorDate: Sun Nov 10 22:03:16 2024 +0800
Add more test cases on EncryptShowCreateTableMergedResult (#33609)
---
.../encrypt/merge/dql/EncryptMergedResult.java | 10 +-
.../encrypt/merge/dql/EncryptMergedResultTest.java | 104 ++++++++++++++++++++-
2 files changed, 108 insertions(+), 6 deletions(-)
diff --git a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/merge/dql/EncryptMergedResult.java b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/merge/dql/EncryptMergedResult.java
index 4eafb680c7a..c36d8075c8e 100644
--- a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/merge/dql/EncryptMergedResult.java
+++ b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/merge/dql/EncryptMergedResult.java
@@ -65,14 +65,14 @@ public final class EncryptMergedResult implements MergedResult {
ShardingSphereDatabase database = metaData.containsDatabase(columnProjection.get().getColumnBoundInfo().getOriginalDatabase().getValue())
? metaData.getDatabase(columnProjection.get().getColumnBoundInfo().getOriginalDatabase().getValue())
: this.database;
- EncryptRule encryptRule = database.getRuleMetaData().getSingleRule(EncryptRule.class);
- if (!encryptRule.findEncryptTable(originalTableName).map(optional -> optional.isEncryptColumn(originalColumnName)).orElse(false)) {
+ EncryptRule rule = database.getRuleMetaData().getSingleRule(EncryptRule.class);
+ if (!rule.findEncryptTable(originalTableName).map(optional -> optional.isEncryptColumn(originalColumnName)).orElse(false)) {
return mergedResult.getValue(columnIndex, type);
}
Object cipherValue = mergedResult.getValue(columnIndex, Object.class);
- EncryptColumn encryptColumn = encryptRule.getEncryptTable(originalTableName).getEncryptColumn(originalColumnName);
- String schemaName =
- selectStatementContext.getTablesContext().getSchemaName().orElseGet(() -> new DatabaseTypeRegistry(selectStatementContext.getDatabaseType()).getDefaultSchemaName(database.getName()));
+ EncryptColumn encryptColumn = rule.getEncryptTable(originalTableName).getEncryptColumn(originalColumnName);
+ String schemaName = selectStatementContext.getTablesContext().getSchemaName()
+ .orElseGet(() -> new DatabaseTypeRegistry(selectStatementContext.getDatabaseType()).getDefaultSchemaName(database.getName()));
try {
return encryptColumn.getCipher().decrypt(database.getName(), schemaName, originalTableName, originalColumnName, cipherValue);
// CHECKSTYLE:OFF
diff --git a/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/merge/dql/EncryptMergedResultTest.java b/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/merge/dql/EncryptMergedResultTest.java
index 13f0082f2df..b4af5ca3457 100644
--- a/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/merge/dql/EncryptMergedResultTest.java
+++ b/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/merge/dql/EncryptMergedResultTest.java
@@ -17,37 +17,61 @@
package org.apache.shardingsphere.encrypt.merge.dql;
+import org.apache.shardingsphere.encrypt.exception.data.DecryptFailedException;
+import org.apache.shardingsphere.encrypt.rule.EncryptRule;
+import org.apache.shardingsphere.encrypt.rule.column.EncryptColumn;
+import org.apache.shardingsphere.encrypt.rule.column.item.CipherColumnItem;
+import org.apache.shardingsphere.encrypt.rule.table.EncryptTable;
+import org.apache.shardingsphere.encrypt.spi.EncryptAlgorithm;
+import org.apache.shardingsphere.infra.algorithm.core.context.AlgorithmSQLContext;
+import org.apache.shardingsphere.infra.binder.context.segment.select.projection.impl.ColumnProjection;
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.ShardingSphereMetaData;
import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
+import org.apache.shardingsphere.infra.metadata.database.rule.RuleMetaData;
+import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.bound.ColumnSegmentBoundInfo;
+import org.apache.shardingsphere.sql.parser.statement.core.value.identifier.IdentifierValue;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Answers;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
import java.io.InputStream;
import java.io.Reader;
import java.sql.SQLException;
import java.util.Calendar;
+import java.util.Collections;
import java.util.Date;
+import java.util.Optional;
+import static org.apache.shardingsphere.test.matcher.ShardingSphereArgumentVerifyMatchers.deepEq;
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.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
class EncryptMergedResultTest {
+ private final DatabaseType databaseType = TypedSPILoader.getService(DatabaseType.class, "FIXTURE");
+
@Mock
private ShardingSphereDatabase database;
@Mock
private ShardingSphereMetaData metaData;
- @Mock
+ @Mock(answer = Answers.RETURNS_DEEP_STUBS)
private SelectStatementContext selectStatementContext;
@Mock
@@ -58,6 +82,84 @@ class EncryptMergedResultTest {
assertFalse(new EncryptMergedResult(database, metaData, selectStatementContext, mergedResult).next());
}
+ @Test
+ void assertGetValueWithoutColumnProjection() throws SQLException {
+ when(selectStatementContext.findColumnProjection(1)).thenReturn(Optional.empty());
+ when(mergedResult.getValue(1, String.class)).thenReturn("foo_value");
+ assertThat(new EncryptMergedResult(database, metaData, selectStatementContext, mergedResult).getValue(1, String.class), is("foo_value"));
+ }
+
+ @Test
+ void assertGetValueWithoutEncryptTable() throws SQLException {
+ ColumnProjection columnProjection = new ColumnProjection("bar_tbl", "foo_col", "foo_alias", databaseType);
+ columnProjection.setColumnBoundInfo(new ColumnSegmentBoundInfo(new IdentifierValue("foo_col")));
+ when(selectStatementContext.findColumnProjection(1)).thenReturn(Optional.of(columnProjection));
+ EncryptRule rule = mockRule(mock(EncryptAlgorithm.class));
+ when(database.getRuleMetaData()).thenReturn(new RuleMetaData(Collections.singleton(rule)));
+ when(mergedResult.getValue(1, String.class)).thenReturn("foo_value");
+ assertThat(new EncryptMergedResult(database, metaData, selectStatementContext, mergedResult).getValue(1, String.class), is("foo_value"));
+ }
+
+ @Test
+ void assertGetValueWithoutEncryptColumn() throws SQLException {
+ ColumnProjection columnProjection = new ColumnProjection("foo_tbl", "bar_col", "bar_alias", databaseType);
+ columnProjection.setColumnBoundInfo(new ColumnSegmentBoundInfo(new IdentifierValue("bar_col")));
+ when(selectStatementContext.findColumnProjection(1)).thenReturn(Optional.of(columnProjection));
+ EncryptRule rule = mockRule(mock(EncryptAlgorithm.class));
+ when(database.getRuleMetaData()).thenReturn(new RuleMetaData(Collections.singleton(rule)));
+ when(mergedResult.getValue(1, String.class)).thenReturn("foo_value");
+ assertThat(new EncryptMergedResult(database, metaData, selectStatementContext, mergedResult).getValue(1, String.class), is("foo_value"));
+ }
+
+ @Test
+ void assertGetValueWithEncryptColumn() throws SQLException {
+ ColumnProjection columnProjection = new ColumnProjection("foo_tbl", "foo_col", "foo_alias", databaseType);
+ columnProjection.setColumnBoundInfo(new ColumnSegmentBoundInfo(
+ new IdentifierValue("foo_db"), new IdentifierValue("foo_schema"), new IdentifierValue("foo_tbl"), new IdentifierValue("foo_col")));
+ when(selectStatementContext.findColumnProjection(1)).thenReturn(Optional.of(columnProjection));
+ when(selectStatementContext.getTablesContext().getSchemaName()).thenReturn(Optional.of("foo_schema"));
+ EncryptAlgorithm encryptAlgorithm = mock(EncryptAlgorithm.class);
+ when(encryptAlgorithm.decrypt(eq("foo_value"), deepEq(new AlgorithmSQLContext("foo_db", "foo_schema", "foo_tbl", "foo_col")))).thenReturn("foo_decrypted_value");
+ EncryptRule rule = mockRule(encryptAlgorithm);
+ ShardingSphereDatabase database = mock(ShardingSphereDatabase.class);
+ when(database.getName()).thenReturn("foo_db");
+ when(database.getRuleMetaData()).thenReturn(new RuleMetaData(Collections.singleton(rule)));
+ when(metaData.containsDatabase("foo_db")).thenReturn(true);
+ when(metaData.getDatabase("foo_db")).thenReturn(database);
+ when(mergedResult.getValue(1, Object.class)).thenReturn("foo_value");
+ assertThat(new EncryptMergedResult(database, metaData, selectStatementContext, mergedResult).getValue(1, String.class), is("foo_decrypted_value"));
+ }
+
+ @Test
+ void assertGetValueFailed() throws SQLException {
+ ColumnProjection columnProjection = new ColumnProjection("foo_tbl", "foo_col", "foo_alias", databaseType);
+ columnProjection.setColumnBoundInfo(new ColumnSegmentBoundInfo(
+ new IdentifierValue("foo_db"), new IdentifierValue("foo_schema"), new IdentifierValue("foo_tbl"), new IdentifierValue("foo_col")));
+ when(selectStatementContext.findColumnProjection(1)).thenReturn(Optional.of(columnProjection));
+ when(selectStatementContext.getTablesContext().getSchemaName()).thenReturn(Optional.of("foo_schema"));
+ EncryptAlgorithm encryptAlgorithm = mock(EncryptAlgorithm.class);
+ when(encryptAlgorithm.decrypt(eq("foo_value"), deepEq(new AlgorithmSQLContext("foo_db", "foo_schema", "foo_tbl", "foo_col")))).thenThrow(new RuntimeException("Test failed"));
+ EncryptRule rule = mockRule(encryptAlgorithm);
+ ShardingSphereDatabase database = mock(ShardingSphereDatabase.class);
+ when(database.getName()).thenReturn("foo_db");
+ when(database.getRuleMetaData()).thenReturn(new RuleMetaData(Collections.singleton(rule)));
+ when(metaData.containsDatabase("foo_db")).thenReturn(true);
+ when(metaData.getDatabase("foo_db")).thenReturn(database);
+ when(mergedResult.getValue(1, Object.class)).thenReturn("foo_value");
+ assertThrows(DecryptFailedException.class, () -> new EncryptMergedResult(database, metaData, selectStatementContext, mergedResult).getValue(1, String.class));
+ }
+
+ private EncryptRule mockRule(final EncryptAlgorithm encryptAlgorithm) {
+ EncryptRule result = mock(EncryptRule.class);
+ EncryptTable encryptTable = mock(EncryptTable.class);
+ when(encryptTable.isEncryptColumn("foo_col")).thenReturn(true);
+ EncryptColumn encryptColumn = new EncryptColumn("foo_col", new CipherColumnItem("foo_cipher_col", encryptAlgorithm));
+ when(encryptTable.getEncryptColumn("foo_col")).thenReturn(encryptColumn);
+ when(result.findEncryptTable("foo_tbl")).thenReturn(Optional.of(encryptTable));
+ when(result.getEncryptTable("foo_tbl")).thenReturn(encryptTable);
+ return result;
+ }
+
@Test
void assertGetCalendarValue() throws SQLException {
Calendar calendar = Calendar.getInstance();