This is an automated email from the ASF dual-hosted git repository.
xiaoyu 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 de3d4c6 Revise #9259 (#9329)
de3d4c6 is described below
commit de3d4c6f7c2cd487f1d936da719123e612239016
Author: Liang Zhang <[email protected]>
AuthorDate: Thu Feb 4 20:11:13 2021 +0800
Revise #9259 (#9329)
* Code format for SingleTableRuleLoaderTest
* Refactor SingleTableRuleLoaderTest
* Refactor SingleTableRuleLoaderTest
* Refactor SingleTableRuleLoaderTest
---
.../rule/single/SingleTableRuleLoaderTest.java | 133 ++++++++-------------
1 file changed, 51 insertions(+), 82 deletions(-)
diff --git
a/shardingsphere-features/shardingsphere-sharding/shardingsphere-sharding-common/src/test/java/org/apache/shardingsphere/sharding/rule/single/SingleTableRuleLoaderTest.java
b/shardingsphere-features/shardingsphere-sharding/shardingsphere-sharding-common/src/test/java/org/apache/shardingsphere/sharding/rule/single/SingleTableRuleLoaderTest.java
index d81a480..56b23a7 100644
---
a/shardingsphere-features/shardingsphere-sharding/shardingsphere-sharding-common/src/test/java/org/apache/shardingsphere/sharding/rule/single/SingleTableRuleLoaderTest.java
+++
b/shardingsphere-features/shardingsphere-sharding/shardingsphere-sharding-common/src/test/java/org/apache/shardingsphere/sharding/rule/single/SingleTableRuleLoaderTest.java
@@ -17,116 +17,85 @@
package org.apache.shardingsphere.sharding.rule.single;
-import com.google.common.base.Strings;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Sets;
import org.apache.shardingsphere.infra.database.type.DatabaseType;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
-import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import javax.sql.DataSource;
-import java.sql.Connection;
-import java.sql.DatabaseMetaData;
import java.sql.ResultSet;
import java.sql.SQLException;
+import java.util.Arrays;
+import java.util.Collection;
import java.util.Collections;
-import java.util.Map;
import java.util.HashMap;
import java.util.List;
-import java.util.Set;
+import java.util.Map;
import java.util.stream.Collectors;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
-public class SingleTableRuleLoaderTest {
-
+public final class SingleTableRuleLoaderTest {
+
private static final String TABLE_TYPE = "TABLE";
-
+
private static final String VIEW_TYPE = "VIEW";
-
+
private static final String TABLE_NAME = "TABLE_NAME";
-
- private final Map<String, DataSource> dataSourceMap = new HashMap<>();
-
- @Mock
- private DatabaseType dbType;
-
- private DataSource initDataSource(final String dataSourceName, final
Set<String> tables) throws SQLException {
- if (Strings.isNullOrEmpty(dataSourceName) || tables == null) {
- throw new IllegalArgumentException("dataSourceNam is empty or
tables is null");
- }
- DataSource dataSource = mock(DataSource.class);
- Connection conn = mock(Connection.class);
- when(dataSource.getConnection()).thenReturn(conn);
- when(conn.getCatalog()).thenReturn(dataSourceName);
-
- ResultSet resultSet = mock(ResultSet.class);
- List<String> tableList = Lists.newArrayList(tables);
- if (tableList.size() == 0) {
- when(resultSet.next()).thenReturn(false);
- } else if (tableList.size() == 1) {
- when(resultSet.next()).thenReturn(true, false);
- when(resultSet.getString(TABLE_NAME)).thenReturn(tableList.get(0));
- } else {
- List<String> subTableList = tableList.subList(1, tables.size());
- List<Boolean> subNextList = subTableList.stream()
- .map(item -> true)
- .collect(Collectors.toList());
- subNextList.add(false);
- String[] subTableArray = new String[subTableList.size()];
- Boolean[] subNextArray = new Boolean[subNextList.size()];
- subTableList.toArray(subTableArray);
- subNextList.toArray(subNextArray);
- when(resultSet.next()).thenReturn(true, subNextArray);
- when(resultSet.getString(TABLE_NAME)).thenReturn(tableList.get(0),
subTableArray);
- }
-
- DatabaseMetaData metaData = mock(DatabaseMetaData.class);
- when(conn.getMetaData()).thenReturn(metaData);
-
- when(
- metaData.getTables(conn.getCatalog(), conn.getSchema(), null, new
String[]{TABLE_TYPE, VIEW_TYPE})
- ).thenReturn(resultSet);
- return dataSource;
- }
-
+
+ private Map<String, DataSource> dataSourceMap;
+
@Before
- public void init() throws SQLException {
- DataSource ds1 = initDataSource("ds1", Sets.newHashSet("employee",
"dept", "salary"));
- DataSource ds2 = initDataSource("ds2", Sets.newHashSet("student",
"teacher", "class", "salary"));
- dataSourceMap.put("ds1", ds1);
- dataSourceMap.put("ds2", ds2);
+ public void setUp() throws SQLException {
+ dataSourceMap = new HashMap<>(2, 1);
+ dataSourceMap.put("ds0", mockDataSource("ds0",
Arrays.asList("employee", "dept", "salary")));
+ dataSourceMap.put("ds1", mockDataSource("ds1",
Arrays.asList("student", "teacher", "class", "salary")));
}
-
+
+ private DataSource mockDataSource(final String dataSourceName, final
List<String> tableNames) throws SQLException {
+ DataSource result = mock(DataSource.class, RETURNS_DEEP_STUBS);
+ when(result.getConnection().getCatalog()).thenReturn(dataSourceName);
+ ResultSet resultSet = mockResultSet(tableNames);
+ when(result.getConnection().getMetaData().getTables(dataSourceName,
null, null, new String[]{TABLE_TYPE, VIEW_TYPE})).thenReturn(resultSet);
+ return result;
+ }
+
+ private ResultSet mockResultSet(final List<String> tableNames) throws
SQLException {
+ ResultSet result = mock(ResultSet.class);
+ String firstTableName = tableNames.get(0);
+ Collection<String> remainTableNames = tableNames.subList(1,
tableNames.size());
+ Collection<Boolean> remainNextResults =
remainTableNames.stream().map(each -> true).collect(Collectors.toList());
+ remainNextResults.add(false);
+ when(result.next()).thenReturn(true, remainNextResults.toArray(new
Boolean[tableNames.size()]));
+ when(result.getString(TABLE_NAME)).thenReturn(firstTableName,
remainTableNames.toArray(new String[tableNames.size() - 1]));
+ return result;
+ }
+
@Test
public void assertLoad() {
- Map<String, SingleTableRule> singleTableRuleMap =
SingleTableRuleLoader.load(dbType, dataSourceMap, Collections.emptyList());
- Set<String> tableSet = singleTableRuleMap.keySet();
- assertTrue(tableSet.contains("employee"));
- assertTrue(tableSet.contains("dept"));
- assertTrue(tableSet.contains("salary"));
- assertTrue(tableSet.contains("student"));
- assertTrue(tableSet.contains("teacher"));
- assertTrue(tableSet.contains("class"));
+ Collection<String> tableNames =
SingleTableRuleLoader.load(mock(DatabaseType.class), dataSourceMap,
Collections.emptyList()).keySet();
+ assertTrue(tableNames.contains("employee"));
+ assertTrue(tableNames.contains("dept"));
+ assertTrue(tableNames.contains("salary"));
+ assertTrue(tableNames.contains("student"));
+ assertTrue(tableNames.contains("teacher"));
+ assertTrue(tableNames.contains("class"));
}
-
+
@Test
- public void assertLoadWithExcludeTable() {
- Map<String, SingleTableRule> singleTableRuleMap =
SingleTableRuleLoader.load(dbType, dataSourceMap,
- Sets.newHashSet("salary", "employee", "student"));
- Set<String> tableSet = singleTableRuleMap.keySet();
- assertFalse(tableSet.contains("employee"));
- assertFalse(tableSet.contains("salary"));
- assertFalse(tableSet.contains("student"));
- assertTrue(tableSet.contains("dept"));
- assertTrue(tableSet.contains("teacher"));
- assertTrue(tableSet.contains("class"));
+ public void assertLoadWithExcludeTables() {
+ Collection<String> tableNames =
SingleTableRuleLoader.load(mock(DatabaseType.class), dataSourceMap,
Arrays.asList("salary", "employee", "student")).keySet();
+ assertFalse(tableNames.contains("employee"));
+ assertFalse(tableNames.contains("salary"));
+ assertFalse(tableNames.contains("student"));
+ assertTrue(tableNames.contains("dept"));
+ assertTrue(tableNames.contains("teacher"));
+ assertTrue(tableNames.contains("class"));
}
}
