Add test cases on EncryptRule.findQueryEncryptor (#32266)

* Add test cases on EncryptColumn

* Add test cases on EncryptTable

* Add test cases on EncryptRule

Author: terrymanu

features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rule/EncryptRuleTest.java

@@ -35,11 +35,13 @@
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Properties;
 import java.util.stream.Stream;
 
 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;
 
@@ -73,24 +75,6 @@ private EncryptRuleConfiguration createEncryptRuleConfiguration() {
                 new AlgorithmConfiguration("CORE.QUERY_ASSISTED.FIXTURE", new Properties()), new AlgorithmConfiguration("CORE.QUERY_LIKE.FIXTURE", new Properties())));
     }
 
-    @Test
-    void assertAssistedQueryEncryptorNameSpecified() {
-        EncryptColumnRuleConfiguration pwdColumnConfig =
-                new EncryptColumnRuleConfiguration("pwd", new EncryptColumnItemRuleConfiguration("pwd_cipher", "standard_encryptor"));
-        pwdColumnConfig.setAssistedQuery(new EncryptColumnItemRuleConfiguration("pwd_assist", "assisted_query_test_encryptor"));
-        assertTrue(pwdColumnConfig.getAssistedQuery().isPresent());
-        assertThat(pwdColumnConfig.getAssistedQuery().get().getEncryptorName(), is("assisted_query_test_encryptor"));
-    }
-    
-    @Test
-    void assertLikeQueryEncryptorNameSpecified() {
-        EncryptColumnRuleConfiguration pwdColumnConfig =
-                new EncryptColumnRuleConfiguration("pwd", new EncryptColumnItemRuleConfiguration("pwd_cipher", "standard_encryptor"));
-        pwdColumnConfig.setLikeQuery(new EncryptColumnItemRuleConfiguration("pwd_like", "like_query_test_encryptor"));
-        assertTrue(pwdColumnConfig.getLikeQuery().isPresent());
-        assertThat(pwdColumnConfig.getLikeQuery().get().getEncryptorName(), is("like_query_test_encryptor"));
-    }
-    
     private Map<String, AlgorithmConfiguration> getEncryptors(final AlgorithmConfiguration standardEncryptConfig, final AlgorithmConfiguration queryAssistedEncryptConfig,
                                                               final AlgorithmConfiguration queryLikeEncryptConfig) {
         Map<String, AlgorithmConfiguration> result = new HashMap<>(3, 1F);
@@ -100,6 +84,18 @@ private Map<String, AlgorithmConfiguration> getEncryptors(final AlgorithmConfigu
         return result;
     }
 
+    @Test
+    void assertFindQueryEncryptor() {
+        EncryptRule encryptRule = new EncryptRule("foo_db", createEncryptRuleConfiguration());
+        assertThat(encryptRule.findQueryEncryptor("t_encrypt", "credit_card"),
+                is(Optional.of(encryptRule.getEncryptTable("t_encrypt").getEncryptColumn("credit_card").getCipher().getEncryptor())));
+    }
+    
+    @Test
+    void assertNotFindQueryEncryptor() {
+        assertFalse(new EncryptRule("foo_db", createEncryptRuleConfiguration()).findQueryEncryptor("t_encrypt", "invalid_col").isPresent());
+    }
+    
     @SuppressWarnings("unused")
     @ParameterizedTest(name = "Wrong{0}")
     @ArgumentsSource(TestCaseArgumentsProvider.class)

features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rule/column/EncryptColumnTest.java

@@ -0,0 +1,44 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shardingsphere.encrypt.rule.column;
+
+import org.apache.shardingsphere.encrypt.rule.column.item.AssistedQueryColumnItem;
+import org.apache.shardingsphere.encrypt.rule.column.item.CipherColumnItem;
+import org.apache.shardingsphere.encrypt.spi.EncryptAlgorithm;
+import org.junit.jupiter.api.Test;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.mockito.Mockito.mock;
+
+class EncryptColumnTest {
+    
+    @Test
+    void assertGetQueryEncryptorWithoutAssistedQuery() {
+        EncryptAlgorithm cipherAlgorithm = mock(EncryptAlgorithm.class);
+        assertThat(new EncryptColumn("foo_tbl", new CipherColumnItem("foo_col", cipherAlgorithm)).getQueryEncryptor(), is(cipherAlgorithm));
+    }
+    
+    @Test
+    void assertGetQueryEncryptorWithAssistedQuery() {
+        EncryptColumn encryptColumn = new EncryptColumn("foo_tbl", new CipherColumnItem("foo_cipher_col", mock(EncryptAlgorithm.class)));
+        EncryptAlgorithm assistedQueryAlgorithm = mock(EncryptAlgorithm.class);
+        encryptColumn.setAssistedQuery(new AssistedQueryColumnItem("foo_assisted_query_col", assistedQueryAlgorithm));
+        assertThat(encryptColumn.getQueryEncryptor(), is(assistedQueryAlgorithm));
+    }
+}

features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rule/table/EncryptTableTest.java

@@ -26,6 +26,9 @@
 import org.junit.jupiter.api.Test;
 
 import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
 
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
@@ -44,8 +47,11 @@ void setUp() {
         EncryptColumnRuleConfiguration columnRuleConfig = new EncryptColumnRuleConfiguration("logicColumn", new EncryptColumnItemRuleConfiguration("cipherColumn", "myEncryptor"));
         columnRuleConfig.setAssistedQuery(new EncryptColumnItemRuleConfiguration("assistedQueryColumn", "foo_assist_query_encryptor"));
         columnRuleConfig.setLikeQuery(new EncryptColumnItemRuleConfiguration("likeQueryColumn", "foo_like_encryptor"));
-        encryptTable = new EncryptTable(new EncryptTableRuleConfiguration("t_encrypt",
-                Collections.singleton(columnRuleConfig)), Collections.singletonMap("myEncryptor", mock(EncryptAlgorithm.class)));
+        Map<String, EncryptAlgorithm> encryptors = new HashMap<>(3, 1F);
+        encryptors.put("myEncryptor", mock(EncryptAlgorithm.class));
+        encryptors.put("foo_assist_query_encryptor", mock(EncryptAlgorithm.class));
+        encryptors.put("foo_like_encryptor", mock(EncryptAlgorithm.class));
+        encryptTable = new EncryptTable(new EncryptTableRuleConfiguration("t_encrypt", Collections.singleton(columnRuleConfig)), encryptors);
     }
 
     @Test
@@ -92,4 +98,15 @@ void assertGetEncryptColumn() {
     void assertGetLogicColumnByCipherColumnWhenNotFind() {
         assertThrows(EncryptLogicColumnNotFoundException.class, () -> encryptTable.getLogicColumnByCipherColumn("invalidColumn"));
     }
+    
+    @Test
+    void assertFindQueryEncryptor() {
+        assertTrue(encryptTable.getEncryptColumn("logicColumn").getAssistedQuery().isPresent());
+        assertThat(encryptTable.findQueryEncryptor("logicColumn"), is(Optional.of(encryptTable.getEncryptColumn("logicColumn").getAssistedQuery().get().getEncryptor())));
+    }
+    
+    @Test
+    void assertFindQueryEncryptorWithNotEncryptColumn() {
+        assertThat(encryptTable.findQueryEncryptor("invalidColumn"), is(Optional.empty()));
+    }
 }