134130 commented on issue #27879:
URL:
https://github.com/apache/shardingsphere/issues/27879#issuecomment-1666781347
```java
package org.apache.shardingsphere.driver;
import com.zaxxer.hikari.HikariDataSource;
import groovy.lang.Tuple2;
import org.apache.shardingsphere.driver.api.ShardingSphereDataSourceFactory;
import
org.apache.shardingsphere.infra.config.algorithm.AlgorithmConfiguration;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
import org.apache.shardingsphere.mask.api.config.MaskRuleConfiguration;
import
org.apache.shardingsphere.mask.api.config.rule.MaskColumnRuleConfiguration;
import
org.apache.shardingsphere.mask.api.config.rule.MaskTableRuleConfiguration;
import org.junit.jupiter.api.Test;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
public class CooperTests {
private static List<Tuple2<String, Integer>> getSQLs() {
List<Tuple2<String, Integer>> result = new ArrayList<>();
result.add(new Tuple2<>("SELECT * FROM film_actor JOIN actor AS a ON
a.actor_id JOIN film AS f ON f.film_id LIMIT 1", 21));
result.add(new Tuple2<>("SELECT a.first_name, f.title FROM
film_actor JOIN actor AS a ON a.actor_id JOIN film AS f ON f.film_id LIMIT 1",
2));
return result;
}
@Test
public void no_mask_test() throws SQLException {
MaskRuleConfiguration maskRule =
createMaskRule(Collections.emptyList());
DataSource dataSource =
createDataSource(Collections.singleton(maskRule));
for (Tuple2<String, Integer> sql : getSQLs()) {
try (Connection connection = dataSource.getConnection()) {
ResultSet resultSet =
connection.createStatement().executeQuery(sql.getV1());
assertThat(resultSet.getMetaData().getColumnCount(),
is(sql.getV2()));
}
}
}
@Test
public void first_name_mask_test() throws SQLException {
MaskRuleConfiguration maskRule =
createMaskRule(Collections.singleton(createMaskTableRule("actor",
"first_name")));
DataSource dataSource =
createDataSource(Collections.singleton(maskRule));
for (Tuple2<String, Integer> sql : getSQLs()) {
try (Connection connection = dataSource.getConnection()) {
ResultSet resultSet =
connection.createStatement().executeQuery(sql.getV1());
assertThat(resultSet.getMetaData().getColumnCount(),
is(sql.getV2()));
}
}
}
@Test
public void first_name_and_title_mask_test() throws SQLException {
MaskRuleConfiguration actorMaskRule = createMaskRule(
Collections.singleton(createMaskTableRule("actor",
"first_name")));
MaskRuleConfiguration filmMaskRule = createMaskRule(
Collections.singleton(createMaskTableRule("film", "title")));
Collection<RuleConfiguration> maskRules =
Arrays.asList(actorMaskRule, filmMaskRule);
DataSource dataSource = createDataSource(maskRules);
for (Tuple2<String, Integer> sql : getSQLs()) {
try (Connection connection = dataSource.getConnection()) {
ResultSet resultSet =
connection.createStatement().executeQuery(sql.getV1());
assertThat(resultSet.getMetaData().getColumnCount(),
is(sql.getV2()));
}
}
}
private void query(String sql, Connection connection) throws
SQLException {
ResultSet resultSet = connection.createStatement().executeQuery(sql);
while (resultSet.next()) {
for (int i = 1; i <= resultSet.getMetaData().getColumnCount();
i++) {
System.out.println(resultSet.getMetaData().getColumnName(i)
+ ": " + resultSet.getObject(i));
}
System.out.println();
}
System.out.println("=====================================");
}
private MaskRuleConfiguration
createMaskRule(Collection<MaskTableRuleConfiguration> tableRules) {
Properties props = new Properties();
props.setProperty("first-n", "1");
props.setProperty("last-m", "1");
props.setProperty("replace-char", "*");
AlgorithmConfiguration algorithm = new
AlgorithmConfiguration("KEEP_FIRST_N_LAST_M", props);
Map<String, AlgorithmConfiguration> algorithms =
Collections.singletonMap(
"default_cooper", algorithm);
return new MaskRuleConfiguration(tableRules, algorithms);
}
private MaskTableRuleConfiguration createMaskTableRule(String table,
String column) {
MaskColumnRuleConfiguration columnRule = new
MaskColumnRuleConfiguration(column, "default_cooper");
return new MaskTableRuleConfiguration(table,
Collections.singleton(columnRule));
}
private DataSource createDataSource(Collection<RuleConfiguration>
configs) {
try {
return ShardingSphereDataSourceFactory.createDataSource(
createHikariDataSource(),
configs,
new Properties());
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
private HikariDataSource createHikariDataSource() {
HikariDataSource result = new HikariDataSource();
result.setDriverClassName("com.mysql.jdbc.Driver");
result.setJdbcUrl("jdbc:mysql://localhost:3306/sakila?useSSL=false");
result.setUsername("root");
result.setPassword("root");
return result;
}
}
```
Here is my test code what I used. Sorry for I am not used to Java tests.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
