You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by du...@apache.org on 2023/03/19 04:19:04 UTC
[shardingsphere] branch master updated: Upgrade junit 5 on SQL E2E (#24675)
This is an automated email from the ASF dual-hosted git repository.
duanzhengqiang 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 e78b4661e1b Upgrade junit 5 on SQL E2E (#24675)
e78b4661e1b is described below
commit e78b4661e1b486178fcdbb6611f22301972d5dc3
Author: Liang Zhang <zh...@apache.org>
AuthorDate: Sun Mar 19 12:18:56 2023 +0800
Upgrade junit 5 on SQL E2E (#24675)
* Upgrade junit 5 on SQL E2E
* Upgrade junit 5 on SQL E2E
* Upgrade junit 5 on SQL E2E
---
...2EIT.java => SingleE2EITContainerComposer.java} | 38 ++-
.../test/e2e/engine/dal/BaseDALE2EIT.java | 19 +-
.../test/e2e/engine/dal/GeneralDALE2EIT.java | 62 +++--
.../test/e2e/engine/dcl/BaseDCLE2EIT.java | 33 ++-
.../test/e2e/engine/dcl/GeneralDCLE2EIT.java | 74 ++++--
.../test/e2e/engine/ddl/BaseDDLE2EIT.java | 92 +++----
.../test/e2e/engine/ddl/GeneralDDLE2EIT.java | 98 ++++---
.../test/e2e/engine/dml/AdditionalDMLE2EIT.java | 288 ++++++++++++---------
.../test/e2e/engine/dml/BaseDMLE2EIT.java | 81 +++---
.../test/e2e/engine/dml/GeneralDMLE2EIT.java | 98 ++++---
.../test/e2e/engine/dql/AdditionalDQLE2EIT.java | 218 +++++++++-------
.../test/e2e/engine/dql/BaseDQLE2EIT.java | 67 ++---
.../test/e2e/engine/dql/GeneralDQLE2EIT.java | 145 ++++++-----
.../test/e2e/engine/ral/BaseRALE2EIT.java | 69 ++---
.../test/e2e/engine/ral/GeneralRALE2EIT.java | 69 +++--
.../test/e2e/engine/rdl/BaseRDLE2EIT.java | 63 ++---
.../test/e2e/engine/rdl/GeneralRDLE2EIT.java | 66 +++--
.../test/e2e/engine/rql/BaseRQLE2EIT.java | 19 +-
.../test/e2e/engine/rql/GeneralRQLE2EIT.java | 52 ++--
.../E2EWatcher.java => E2EITExtension.java} | 15 +-
20 files changed, 967 insertions(+), 699 deletions(-)
diff --git a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/SingleE2EIT.java b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/SingleE2EITContainerComposer.java
similarity index 78%
rename from test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/SingleE2EIT.java
rename to test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/SingleE2EITContainerComposer.java
index b05af574ae7..d6f0ad19be0 100644
--- a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/SingleE2EIT.java
+++ b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/SingleE2EITContainerComposer.java
@@ -17,7 +17,6 @@
package org.apache.shardingsphere.test.e2e.engine;
-import lombok.AccessLevel;
import lombok.Getter;
import org.apache.shardingsphere.test.e2e.cases.SQLExecuteType;
import org.apache.shardingsphere.test.e2e.cases.assertion.IntegrationTestCaseAssertion;
@@ -25,26 +24,19 @@ import org.apache.shardingsphere.test.e2e.cases.dataset.DataSet;
import org.apache.shardingsphere.test.e2e.cases.dataset.DataSetLoader;
import org.apache.shardingsphere.test.e2e.cases.value.SQLValue;
import org.apache.shardingsphere.test.e2e.framework.param.model.AssertionTestParameter;
-import org.apache.shardingsphere.test.e2e.framework.runner.ParallelParameterized;
-import org.apache.shardingsphere.test.e2e.framework.watcher.E2EWatcher;
-import org.junit.AfterClass;
-import org.junit.Rule;
-import org.junit.runner.RunWith;
import java.text.ParseException;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
-@RunWith(ParallelParameterized.class)
-@Getter(AccessLevel.PROTECTED)
-public abstract class SingleE2EIT {
-
- @Rule
- @Getter(AccessLevel.NONE)
- public E2EWatcher watcher = new E2EWatcher();
+/**
+ * Single E2E IT container composer.
+ */
+@Getter
+public final class SingleE2EITContainerComposer implements AutoCloseable {
- private final AssertionTestParameter testParam;
+ private final String sql;
private final E2EContainerComposer containerComposer;
@@ -56,8 +48,8 @@ public abstract class SingleE2EIT {
private final DataSet generatedKeyDataSet;
- public SingleE2EIT(final AssertionTestParameter testParam) {
- this.testParam = testParam;
+ public SingleE2EITContainerComposer(final AssertionTestParameter testParam) {
+ sql = testParam.getTestCaseContext().getTestCase().getSql();
containerComposer = new E2EContainerComposer(testParam);
sqlExecuteType = testParam.getSqlExecuteType();
assertion = testParam.getAssertion();
@@ -70,8 +62,14 @@ public abstract class SingleE2EIT {
testParam.getTestCaseContext().getParentPath(), testParam.getScenario(), testParam.getDatabaseType(), testParam.getMode(), assertion.getExpectedGeneratedKeyDataFile());
}
- protected final String getSQL() throws ParseException {
- return sqlExecuteType == SQLExecuteType.Literal ? getLiteralSQL(testParam.getTestCaseContext().getTestCase().getSql()) : testParam.getTestCaseContext().getTestCase().getSql();
+ /**
+ * Get SQL.
+ *
+ * @return SQL
+ * @throws ParseException parse exception
+ */
+ public String getSQL() throws ParseException {
+ return sqlExecuteType == SQLExecuteType.Literal ? getLiteralSQL(sql) : sql;
}
private String getLiteralSQL(final String sql) throws ParseException {
@@ -79,8 +77,8 @@ public abstract class SingleE2EIT {
return params.isEmpty() ? sql : String.format(sql.replace("%", "ÿ").replace("?", "%s"), params.toArray()).replace("ÿ", "%").replace("%%", "%").replace("'%'", "'%%'");
}
- @AfterClass
- public static void closeContainers() {
+ @Override
+ public void close() {
E2EContainerComposer.closeContainers();
}
}
diff --git a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dal/BaseDALE2EIT.java b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dal/BaseDALE2EIT.java
index 4f8e218f7e4..c8a26a365d3 100644
--- a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dal/BaseDALE2EIT.java
+++ b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dal/BaseDALE2EIT.java
@@ -21,8 +21,7 @@ import org.apache.shardingsphere.test.e2e.cases.dataset.metadata.DataSetColumn;
import org.apache.shardingsphere.test.e2e.cases.dataset.metadata.DataSetMetaData;
import org.apache.shardingsphere.test.e2e.cases.dataset.row.DataSetRow;
import org.apache.shardingsphere.test.e2e.engine.E2EContainerComposer;
-import org.apache.shardingsphere.test.e2e.engine.SingleE2EIT;
-import org.apache.shardingsphere.test.e2e.framework.param.model.AssertionTestParameter;
+import org.apache.shardingsphere.test.e2e.engine.SingleE2EITContainerComposer;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
@@ -37,20 +36,16 @@ import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertTrue;
-public abstract class BaseDALE2EIT extends SingleE2EIT {
+public abstract class BaseDALE2EIT {
- public BaseDALE2EIT(final AssertionTestParameter testParam) {
- super(testParam);
+ protected final void assertResultSet(final SingleE2EITContainerComposer containerComposer, final ResultSet resultSet) throws SQLException {
+ assertMetaData(resultSet.getMetaData(), getExpectedColumns(containerComposer));
+ assertRows(resultSet, containerComposer.getDataSet().getRows());
}
- protected final void assertResultSet(final ResultSet resultSet) throws SQLException {
- assertMetaData(resultSet.getMetaData(), getExpectedColumns());
- assertRows(resultSet, getDataSet().getRows());
- }
-
- private Collection<DataSetColumn> getExpectedColumns() {
+ private Collection<DataSetColumn> getExpectedColumns(final SingleE2EITContainerComposer containerComposer) {
Collection<DataSetColumn> result = new LinkedList<>();
- for (DataSetMetaData each : getDataSet().getMetaDataList()) {
+ for (DataSetMetaData each : containerComposer.getDataSet().getMetaDataList()) {
result.addAll(each.getColumns());
}
return result;
diff --git a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dal/GeneralDALE2EIT.java b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dal/GeneralDALE2EIT.java
index c55ab33c827..f9468101a20 100644
--- a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dal/GeneralDALE2EIT.java
+++ b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dal/GeneralDALE2EIT.java
@@ -18,52 +18,68 @@
package org.apache.shardingsphere.test.e2e.engine.dal;
import org.apache.shardingsphere.test.e2e.cases.SQLCommandType;
+import org.apache.shardingsphere.test.e2e.engine.SingleE2EITContainerComposer;
+import org.apache.shardingsphere.test.e2e.framework.E2EITExtension;
import org.apache.shardingsphere.test.e2e.framework.param.array.E2ETestParameterFactory;
import org.apache.shardingsphere.test.e2e.framework.param.model.AssertionTestParameter;
-import org.apache.shardingsphere.test.e2e.framework.runner.ParallelRunningStrategy;
-import org.apache.shardingsphere.test.e2e.framework.runner.ParallelRunningStrategy.ParallelLevel;
-import org.junit.Test;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.api.condition.EnabledIf;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.ArgumentsSource;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.ParseException;
-import java.util.Collection;
+import java.util.stream.Stream;
-@ParallelRunningStrategy(ParallelLevel.SCENARIO)
+@ExtendWith(E2EITExtension.class)
public final class GeneralDALE2EIT extends BaseDALE2EIT {
- public GeneralDALE2EIT(final AssertionTestParameter testParam) {
- super(testParam);
- }
-
- @Parameters(name = "{0}")
- public static Collection<AssertionTestParameter> getTestParameters() {
- return E2ETestParameterFactory.getAssertionTestParameters(SQLCommandType.DAL);
+ @ParameterizedTest(name = "{0}")
+ @EnabledIf("isEnabled")
+ @ArgumentsSource(TestCaseArgumentsProvider.class)
+ public void assertExecute(final AssertionTestParameter testParam) throws SQLException, ParseException {
+ try (SingleE2EITContainerComposer containerComposer = new SingleE2EITContainerComposer(testParam)) {
+ assertExecute(containerComposer);
+ }
}
- @Test
- public void assertExecute() throws SQLException, ParseException {
- try (Connection connection = getContainerComposer().getTargetDataSource().getConnection()) {
+ private void assertExecute(final SingleE2EITContainerComposer containerComposer) throws SQLException, ParseException {
+ try (Connection connection = containerComposer.getContainerComposer().getTargetDataSource().getConnection()) {
try (Statement statement = connection.createStatement()) {
- statement.execute(getSQL());
- assertExecuteResult(statement);
+ statement.execute(containerComposer.getSQL());
+ assertExecuteResult(containerComposer, statement);
}
}
}
- private void assertExecuteResult(final Statement statement) throws SQLException {
+ private void assertExecuteResult(final SingleE2EITContainerComposer containerComposer, final Statement statement) throws SQLException {
try (ResultSet resultSet = statement.getResultSet()) {
- if (null == getAssertion().getAssertionSQL()) {
- assertResultSet(resultSet);
+ if (null == containerComposer.getAssertion().getAssertionSQL()) {
+ assertResultSet(containerComposer, resultSet);
} else {
- statement.execute(getAssertion().getAssertionSQL().getSql());
+ statement.execute(containerComposer.getAssertion().getAssertionSQL().getSql());
try (ResultSet assertionSQLResultSet = statement.getResultSet()) {
- assertResultSet(assertionSQLResultSet);
+ assertResultSet(containerComposer, assertionSQLResultSet);
}
}
}
}
+
+ private static boolean isEnabled() {
+ return E2ETestParameterFactory.containsTestParameter();
+ }
+
+ private static class TestCaseArgumentsProvider implements ArgumentsProvider {
+
+ @Override
+ public Stream<? extends Arguments> provideArguments(final ExtensionContext extensionContext) {
+ return E2ETestParameterFactory.getAssertionTestParameters(SQLCommandType.DAL).stream().map(Arguments::of);
+ }
+ }
}
diff --git a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dcl/BaseDCLE2EIT.java b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dcl/BaseDCLE2EIT.java
index 4bb27f258f7..324d9b367ce 100644
--- a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dcl/BaseDCLE2EIT.java
+++ b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dcl/BaseDCLE2EIT.java
@@ -17,29 +17,36 @@
package org.apache.shardingsphere.test.e2e.engine.dcl;
-import org.apache.shardingsphere.test.e2e.engine.SingleE2EIT;
-import org.apache.shardingsphere.test.e2e.env.runtime.scenario.path.ScenarioCommonPath;
+import org.apache.shardingsphere.test.e2e.engine.SingleE2EITContainerComposer;
import org.apache.shardingsphere.test.e2e.env.runtime.scenario.authority.AuthorityEnvironmentManager;
+import org.apache.shardingsphere.test.e2e.env.runtime.scenario.path.ScenarioCommonPath;
import org.apache.shardingsphere.test.e2e.framework.param.model.AssertionTestParameter;
-import org.junit.After;
-import org.junit.Before;
+import org.junit.jupiter.api.AfterEach;
+
+import javax.xml.bind.JAXBException;
+import java.io.IOException;
+import java.sql.SQLException;
-public abstract class BaseDCLE2EIT extends SingleE2EIT {
+public abstract class BaseDCLE2EIT {
private AuthorityEnvironmentManager authorityEnvironmentManager;
- public BaseDCLE2EIT(final AssertionTestParameter testParam) {
- super(testParam);
- }
-
- @Before
- public final void init() throws Exception {
+ /**
+ * Init.
+ *
+ * @param testParam test parameter
+ * @param containerComposer container composer
+ * @throws JAXBException JAXB exception
+ * @throws IOException IO exception
+ * @throws SQLException SQL exception
+ */
+ public final void init(final AssertionTestParameter testParam, final SingleE2EITContainerComposer containerComposer) throws JAXBException, IOException, SQLException {
authorityEnvironmentManager = new AuthorityEnvironmentManager(
- new ScenarioCommonPath(getTestParam().getScenario()).getAuthorityFile(), getContainerComposer().getActualDataSourceMap(), getTestParam().getDatabaseType());
+ new ScenarioCommonPath(testParam.getScenario()).getAuthorityFile(), containerComposer.getContainerComposer().getActualDataSourceMap(), testParam.getDatabaseType());
authorityEnvironmentManager.initialize();
}
- @After
+ @AfterEach
public final void tearDown() throws Exception {
authorityEnvironmentManager.clean();
}
diff --git a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dcl/GeneralDCLE2EIT.java b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dcl/GeneralDCLE2EIT.java
index a83bacb692a..d4f9b64a0be 100644
--- a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dcl/GeneralDCLE2EIT.java
+++ b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dcl/GeneralDCLE2EIT.java
@@ -19,37 +19,44 @@ package org.apache.shardingsphere.test.e2e.engine.dcl;
import org.apache.shardingsphere.test.e2e.cases.SQLCommandType;
import org.apache.shardingsphere.test.e2e.cases.SQLExecuteType;
+import org.apache.shardingsphere.test.e2e.engine.SingleE2EITContainerComposer;
+import org.apache.shardingsphere.test.e2e.framework.E2EITExtension;
import org.apache.shardingsphere.test.e2e.framework.param.array.E2ETestParameterFactory;
import org.apache.shardingsphere.test.e2e.framework.param.model.AssertionTestParameter;
-import org.apache.shardingsphere.test.e2e.framework.runner.ParallelRunningStrategy;
-import org.apache.shardingsphere.test.e2e.framework.runner.ParallelRunningStrategy.ParallelLevel;
-import org.junit.Test;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.api.condition.EnabledIf;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.ArgumentsSource;
+import javax.xml.bind.JAXBException;
+import java.io.IOException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.ParseException;
-import java.util.Collection;
+import java.util.stream.Stream;
-@ParallelRunningStrategy(ParallelLevel.SCENARIO)
+@ExtendWith(E2EITExtension.class)
public final class GeneralDCLE2EIT extends BaseDCLE2EIT {
- public GeneralDCLE2EIT(final AssertionTestParameter testParam) {
- super(testParam);
- }
-
- @Parameters(name = "{0}")
- public static Collection<AssertionTestParameter> getTestParameters() {
- return E2ETestParameterFactory.getAssertionTestParameters(SQLCommandType.DCL);
+ @ParameterizedTest(name = "{0}")
+ @EnabledIf("isEnabled")
+ @ArgumentsSource(TestCaseArgumentsProvider.class)
+ public void assertExecuteUpdate(final AssertionTestParameter testParam) throws SQLException, ParseException, JAXBException, IOException {
+ try (SingleE2EITContainerComposer containerComposer = new SingleE2EITContainerComposer(testParam)) {
+ init(testParam, containerComposer);
+ assertExecuteUpdate(containerComposer);
+ }
}
- @Test
- public void assertExecuteUpdate() throws SQLException, ParseException {
- String sql = getSQL();
- try (Connection connection = getContainerComposer().getTargetDataSource().getConnection()) {
- if (SQLExecuteType.Literal == getSqlExecuteType()) {
+ private void assertExecuteUpdate(final SingleE2EITContainerComposer containerComposer) throws ParseException, SQLException {
+ String sql = containerComposer.getSQL();
+ try (Connection connection = containerComposer.getContainerComposer().getTargetDataSource().getConnection()) {
+ if (SQLExecuteType.Literal == containerComposer.getSqlExecuteType()) {
try (Statement statement = connection.createStatement()) {
statement.executeUpdate(sql);
}
@@ -61,11 +68,20 @@ public final class GeneralDCLE2EIT extends BaseDCLE2EIT {
}
}
- @Test
- public void assertExecute() throws SQLException, ParseException {
- String sql = getSQL();
- try (Connection connection = getContainerComposer().getTargetDataSource().getConnection()) {
- if (SQLExecuteType.Literal == getSqlExecuteType()) {
+ @ParameterizedTest(name = "{0}")
+ @EnabledIf("isEnabled")
+ @ArgumentsSource(TestCaseArgumentsProvider.class)
+ public void assertExecute(final AssertionTestParameter testParam) throws SQLException, ParseException, JAXBException, IOException {
+ try (SingleE2EITContainerComposer containerComposer = new SingleE2EITContainerComposer(testParam)) {
+ init(testParam, containerComposer);
+ assertExecute(containerComposer);
+ }
+ }
+
+ private void assertExecute(final SingleE2EITContainerComposer containerComposer) throws ParseException, SQLException {
+ String sql = containerComposer.getSQL();
+ try (Connection connection = containerComposer.getContainerComposer().getTargetDataSource().getConnection()) {
+ if (SQLExecuteType.Literal == containerComposer.getSqlExecuteType()) {
try (Statement statement = connection.createStatement()) {
statement.execute(sql);
}
@@ -76,4 +92,16 @@ public final class GeneralDCLE2EIT extends BaseDCLE2EIT {
}
}
}
+
+ private static boolean isEnabled() {
+ return E2ETestParameterFactory.containsTestParameter();
+ }
+
+ private static class TestCaseArgumentsProvider implements ArgumentsProvider {
+
+ @Override
+ public Stream<? extends Arguments> provideArguments(final ExtensionContext extensionContext) {
+ return E2ETestParameterFactory.getAssertionTestParameters(SQLCommandType.DCL).stream().map(Arguments::of);
+ }
+ }
}
diff --git a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/ddl/BaseDDLE2EIT.java b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/ddl/BaseDDLE2EIT.java
index 31e23a39967..f20a22827f0 100644
--- a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/ddl/BaseDDLE2EIT.java
+++ b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/ddl/BaseDDLE2EIT.java
@@ -24,10 +24,8 @@ import org.apache.shardingsphere.infra.util.expr.InlineExpressionParser;
import org.apache.shardingsphere.test.e2e.cases.dataset.metadata.DataSetColumn;
import org.apache.shardingsphere.test.e2e.cases.dataset.metadata.DataSetIndex;
import org.apache.shardingsphere.test.e2e.cases.dataset.metadata.DataSetMetaData;
-import org.apache.shardingsphere.test.e2e.engine.SingleE2EIT;
+import org.apache.shardingsphere.test.e2e.engine.SingleE2EITContainerComposer;
import org.apache.shardingsphere.test.e2e.framework.param.model.AssertionTestParameter;
-import org.junit.After;
-import org.junit.Before;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
@@ -47,26 +45,27 @@ import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
-public abstract class BaseDDLE2EIT extends SingleE2EIT {
+public abstract class BaseDDLE2EIT {
- public BaseDDLE2EIT(final AssertionTestParameter testParam) {
- super(testParam);
- }
-
- @Before
- public final void init() throws Exception {
- assertNotNull(getAssertion().getInitialSQL(), "Init SQL is required");
- assertNotNull(getAssertion().getInitialSQL().getAffectedTable(), "Expected affected table is required");
- try (Connection connection = getContainerComposer().getTargetDataSource().getConnection()) {
- executeInitSQLs(connection);
+ /**
+ * Init.
+ *
+ * @param containerComposer container composer
+ * @throws SQLException SQL exception
+ */
+ public final void init(final SingleE2EITContainerComposer containerComposer) throws SQLException {
+ assertNotNull(containerComposer.getAssertion().getInitialSQL(), "Init SQL is required");
+ assertNotNull(containerComposer.getAssertion().getInitialSQL().getAffectedTable(), "Expected affected table is required");
+ try (Connection connection = containerComposer.getContainerComposer().getTargetDataSource().getConnection()) {
+ executeInitSQLs(containerComposer, connection);
}
}
- private synchronized void executeInitSQLs(final Connection connection) throws SQLException {
- if (null == getAssertion().getInitialSQL().getSql()) {
+ private synchronized void executeInitSQLs(final SingleE2EITContainerComposer containerComposer, final Connection connection) throws SQLException {
+ if (null == containerComposer.getAssertion().getInitialSQL().getSql()) {
return;
}
- for (String each : Splitter.on(";").trimResults().splitToList(getAssertion().getInitialSQL().getSql())) {
+ for (String each : Splitter.on(";").trimResults().splitToList(containerComposer.getAssertion().getInitialSQL().getSql())) {
try (PreparedStatement preparedStatement = connection.prepareStatement(each)) {
preparedStatement.executeUpdate();
}
@@ -74,20 +73,25 @@ public abstract class BaseDDLE2EIT extends SingleE2EIT {
}
}
- @After
- public final void tearDown() throws SQLException {
- if (null != getAssertion().getDestroySQL()) {
- try (Connection connection = getContainerComposer().getTargetDataSource().getConnection()) {
- executeDestroySQLs(connection);
+ /**
+ * Tear down.
+ *
+ * @param containerComposer container composer
+ * @throws SQLException SQL exception
+ */
+ public final void tearDown(final SingleE2EITContainerComposer containerComposer) throws SQLException {
+ if (null != containerComposer.getAssertion().getDestroySQL()) {
+ try (Connection connection = containerComposer.getContainerComposer().getTargetDataSource().getConnection()) {
+ executeDestroySQLs(containerComposer, connection);
}
}
}
- private void executeDestroySQLs(final Connection connection) throws SQLException {
- if (null == getAssertion().getDestroySQL().getSql()) {
+ private void executeDestroySQLs(final SingleE2EITContainerComposer containerComposer, final Connection connection) throws SQLException {
+ if (null == containerComposer.getAssertion().getDestroySQL().getSql()) {
return;
}
- for (String each : Splitter.on(";").trimResults().splitToList(getAssertion().getDestroySQL().getSql())) {
+ for (String each : Splitter.on(";").trimResults().splitToList(containerComposer.getAssertion().getDestroySQL().getSql())) {
try (PreparedStatement preparedStatement = connection.prepareStatement(each)) {
preparedStatement.executeUpdate();
}
@@ -95,25 +99,25 @@ public abstract class BaseDDLE2EIT extends SingleE2EIT {
}
}
- protected final void assertTableMetaData() throws SQLException {
- String tableName = getAssertion().getInitialSQL().getAffectedTable();
- DataSetMetaData expected = getDataSet().findMetaData(tableName);
+ protected final void assertTableMetaData(final AssertionTestParameter testParam, final SingleE2EITContainerComposer containerComposer) throws SQLException {
+ String tableName = containerComposer.getAssertion().getInitialSQL().getAffectedTable();
+ DataSetMetaData expected = containerComposer.getDataSet().findMetaData(tableName);
Collection<DataNode> dataNodes = new InlineExpressionParser(expected.getDataNodes()).splitAndEvaluate().stream().map(DataNode::new).collect(Collectors.toList());
if (expected.getColumns().isEmpty()) {
- assertNotContainsTable(dataNodes);
+ assertNotContainsTable(containerComposer, dataNodes);
return;
}
- assertTableMetaData(getActualColumns(dataNodes), getActualIndexes(dataNodes), expected);
+ assertTableMetaData(testParam, getActualColumns(containerComposer, dataNodes), getActualIndexes(containerComposer, dataNodes), expected);
}
- private void assertTableMetaData(final List<DataSetColumn> actualColumns, final List<DataSetIndex> actualIndexes, final DataSetMetaData expected) {
- assertColumnMetaData(actualColumns, expected.getColumns());
+ private void assertTableMetaData(final AssertionTestParameter testParam, final List<DataSetColumn> actualColumns, final List<DataSetIndex> actualIndexes, final DataSetMetaData expected) {
+ assertColumnMetaData(testParam, actualColumns, expected.getColumns());
assertIndexMetaData(actualIndexes, expected.getIndexes());
}
- private void assertNotContainsTable(final Collection<DataNode> dataNodes) throws SQLException {
+ private void assertNotContainsTable(final SingleE2EITContainerComposer containerComposer, final Collection<DataNode> dataNodes) throws SQLException {
for (DataNode each : dataNodes) {
- try (Connection connection = getContainerComposer().getActualDataSourceMap().get(each.getDataSourceName()).getConnection()) {
+ try (Connection connection = containerComposer.getContainerComposer().getActualDataSourceMap().get(each.getDataSourceName()).getConnection()) {
assertNotContainsTable(connection, each.getTableName());
}
}
@@ -123,10 +127,10 @@ public abstract class BaseDDLE2EIT extends SingleE2EIT {
assertFalse(connection.getMetaData().getTables(null, null, tableName, new String[]{"TABLE"}).next(), String.format("Table `%s` should not existed", tableName));
}
- private List<DataSetColumn> getActualColumns(final Collection<DataNode> dataNodes) throws SQLException {
+ private List<DataSetColumn> getActualColumns(final SingleE2EITContainerComposer containerComposer, final Collection<DataNode> dataNodes) throws SQLException {
Set<DataSetColumn> result = new LinkedHashSet<>();
for (DataNode each : dataNodes) {
- try (Connection connection = getContainerComposer().getActualDataSourceMap().get(each.getDataSourceName()).getConnection()) {
+ try (Connection connection = containerComposer.getContainerComposer().getActualDataSourceMap().get(each.getDataSourceName()).getConnection()) {
result.addAll(getActualColumns(connection, each.getTableName()));
}
}
@@ -148,10 +152,10 @@ public abstract class BaseDDLE2EIT extends SingleE2EIT {
}
}
- private List<DataSetIndex> getActualIndexes(final Collection<DataNode> dataNodes) throws SQLException {
+ private List<DataSetIndex> getActualIndexes(final SingleE2EITContainerComposer containerComposer, final Collection<DataNode> dataNodes) throws SQLException {
Set<DataSetIndex> result = new LinkedHashSet<>();
for (DataNode each : dataNodes) {
- try (Connection connection = getContainerComposer().getActualDataSourceMap().get(each.getDataSourceName()).getConnection()) {
+ try (Connection connection = containerComposer.getContainerComposer().getActualDataSourceMap().get(each.getDataSourceName()).getConnection()) {
result.addAll(getActualIndexes(connection, each.getTableName()));
}
}
@@ -173,20 +177,20 @@ public abstract class BaseDDLE2EIT extends SingleE2EIT {
}
}
- private void assertColumnMetaData(final List<DataSetColumn> actual, final List<DataSetColumn> expected) {
+ private void assertColumnMetaData(final AssertionTestParameter testParam, final List<DataSetColumn> actual, final List<DataSetColumn> expected) {
assertThat("Size of actual columns is different with size of expected columns.", actual.size(), is(expected.size()));
for (int i = 0; i < actual.size(); i++) {
- assertColumnMetaData(actual.get(i), expected.get(i));
+ assertColumnMetaData(testParam, actual.get(i), expected.get(i));
}
}
- private void assertColumnMetaData(final DataSetColumn actual, final DataSetColumn expected) {
+ private void assertColumnMetaData(final AssertionTestParameter testParam, final DataSetColumn actual, final DataSetColumn expected) {
assertThat("Mismatched column name.", actual.getName(), is(expected.getName()));
- if ("MySQL".equals(getTestParam().getDatabaseType().getType()) && "integer".equals(expected.getType())) {
+ if ("MySQL".equals(testParam.getDatabaseType().getType()) && "integer".equals(expected.getType())) {
assertThat("Mismatched column type.", actual.getType(), is("int"));
- } else if ("PostgreSQL".equals(getTestParam().getDatabaseType().getType()) && "integer".equals(expected.getType())) {
+ } else if ("PostgreSQL".equals(testParam.getDatabaseType().getType()) && "integer".equals(expected.getType())) {
assertThat("Mismatched column type.", actual.getType(), is("int4"));
- } else if ("openGauss".equals(getTestParam().getDatabaseType().getType()) && "integer".equals(expected.getType())) {
+ } else if ("openGauss".equals(testParam.getDatabaseType().getType()) && "integer".equals(expected.getType())) {
assertThat("Mismatched column type.", actual.getType(), is("int4"));
} else {
assertThat("Mismatched column type.", actual.getType(), is(expected.getType()));
diff --git a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/ddl/GeneralDDLE2EIT.java b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/ddl/GeneralDDLE2EIT.java
index b945465dd94..4cda560a1a4 100644
--- a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/ddl/GeneralDDLE2EIT.java
+++ b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/ddl/GeneralDDLE2EIT.java
@@ -19,83 +19,103 @@ package org.apache.shardingsphere.test.e2e.engine.ddl;
import org.apache.shardingsphere.test.e2e.cases.SQLCommandType;
import org.apache.shardingsphere.test.e2e.cases.SQLExecuteType;
+import org.apache.shardingsphere.test.e2e.engine.SingleE2EITContainerComposer;
+import org.apache.shardingsphere.test.e2e.framework.E2EITExtension;
import org.apache.shardingsphere.test.e2e.framework.param.array.E2ETestParameterFactory;
import org.apache.shardingsphere.test.e2e.framework.param.model.AssertionTestParameter;
-import org.apache.shardingsphere.test.e2e.framework.runner.ParallelRunningStrategy;
-import org.apache.shardingsphere.test.e2e.framework.runner.ParallelRunningStrategy.ParallelLevel;
-import org.junit.Test;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.api.condition.EnabledIf;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.ArgumentsSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.ParseException;
-import java.util.Collection;
+import java.util.stream.Stream;
import static org.junit.jupiter.api.Assertions.assertFalse;
-@ParallelRunningStrategy(ParallelLevel.SCENARIO)
+@ExtendWith(E2EITExtension.class)
public final class GeneralDDLE2EIT extends BaseDDLE2EIT {
- public GeneralDDLE2EIT(final AssertionTestParameter testParam) {
- super(testParam);
- }
-
- @Parameters(name = "{0}")
- public static Collection<AssertionTestParameter> getTestParameters() {
- return E2ETestParameterFactory.getAssertionTestParameters(SQLCommandType.DDL);
- }
-
- @Test
- public void assertExecuteUpdate() throws SQLException, ParseException {
- try (Connection connection = getContainerComposer().getTargetDataSource().getConnection()) {
- if (SQLExecuteType.Literal == getSqlExecuteType()) {
- executeUpdateForStatement(connection);
- } else {
- executeUpdateForPreparedStatement(connection);
+ @ParameterizedTest(name = "{0}")
+ @EnabledIf("isEnabled")
+ @ArgumentsSource(TestCaseArgumentsProvider.class)
+ public void assertExecuteUpdate(final AssertionTestParameter testParam) throws SQLException, ParseException {
+ try (SingleE2EITContainerComposer containerComposer = new SingleE2EITContainerComposer(testParam)) {
+ init(containerComposer);
+ try (Connection connection = containerComposer.getContainerComposer().getTargetDataSource().getConnection()) {
+ if (SQLExecuteType.Literal == containerComposer.getSqlExecuteType()) {
+ executeUpdateForStatement(containerComposer, connection);
+ } else {
+ executeUpdateForPreparedStatement(containerComposer, connection);
+ }
+ assertTableMetaData(testParam, containerComposer);
}
- assertTableMetaData();
+ tearDown(containerComposer);
}
}
- private void executeUpdateForStatement(final Connection connection) throws SQLException, ParseException {
+ private void executeUpdateForStatement(final SingleE2EITContainerComposer containerComposer, final Connection connection) throws SQLException, ParseException {
try (Statement statement = connection.createStatement()) {
- assertFalse(statement.executeUpdate(getSQL()) > 0, "Not a DDL statement.");
+ assertFalse(statement.executeUpdate(containerComposer.getSQL()) > 0, "Not a DDL statement.");
}
waitCompleted();
}
- private void executeUpdateForPreparedStatement(final Connection connection) throws SQLException, ParseException {
- try (PreparedStatement preparedStatement = connection.prepareStatement(getSQL())) {
+ private void executeUpdateForPreparedStatement(final SingleE2EITContainerComposer containerComposer, final Connection connection) throws SQLException, ParseException {
+ try (PreparedStatement preparedStatement = connection.prepareStatement(containerComposer.getSQL())) {
assertFalse(preparedStatement.executeUpdate() > 0, "Not a DDL statement.");
}
waitCompleted();
}
- @Test
- public void assertExecute() throws SQLException, ParseException {
- try (Connection connection = getContainerComposer().getTargetDataSource().getConnection()) {
- if (SQLExecuteType.Literal == getSqlExecuteType()) {
- executeForStatement(connection);
- } else {
- executeForPreparedStatement(connection);
+ @ParameterizedTest(name = "{0}")
+ @EnabledIf("isEnabled")
+ @ArgumentsSource(TestCaseArgumentsProvider.class)
+ public void assertExecute(final AssertionTestParameter testParam) throws Exception {
+ try (SingleE2EITContainerComposer containerComposer = new SingleE2EITContainerComposer(testParam)) {
+ init(containerComposer);
+ try (Connection connection = containerComposer.getContainerComposer().getTargetDataSource().getConnection()) {
+ if (SQLExecuteType.Literal == containerComposer.getSqlExecuteType()) {
+ executeForStatement(containerComposer, connection);
+ } else {
+ executeForPreparedStatement(containerComposer, connection);
+ }
+ assertTableMetaData(testParam, containerComposer);
}
- assertTableMetaData();
+ tearDown(containerComposer);
}
}
- private void executeForStatement(final Connection connection) throws SQLException, ParseException {
+ private void executeForStatement(final SingleE2EITContainerComposer containerComposer, final Connection connection) throws SQLException, ParseException {
try (Statement statement = connection.createStatement()) {
- assertFalse(statement.execute(getSQL()), "Not a DDL statement.");
+ assertFalse(statement.execute(containerComposer.getSQL()), "Not a DDL statement.");
}
waitCompleted();
}
- private void executeForPreparedStatement(final Connection connection) throws SQLException, ParseException {
- try (PreparedStatement preparedStatement = connection.prepareStatement(getSQL())) {
+ private void executeForPreparedStatement(final SingleE2EITContainerComposer containerComposer, final Connection connection) throws SQLException, ParseException {
+ try (PreparedStatement preparedStatement = connection.prepareStatement(containerComposer.getSQL())) {
assertFalse(preparedStatement.execute(), "Not a DDL statement.");
}
waitCompleted();
}
+
+ private static boolean isEnabled() {
+ return E2ETestParameterFactory.containsTestParameter();
+ }
+
+ private static class TestCaseArgumentsProvider implements ArgumentsProvider {
+
+ @Override
+ public Stream<? extends Arguments> provideArguments(final ExtensionContext extensionContext) {
+ return E2ETestParameterFactory.getAssertionTestParameters(SQLCommandType.DDL).stream().map(Arguments::of);
+ }
+ }
}
diff --git a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dml/AdditionalDMLE2EIT.java b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dml/AdditionalDMLE2EIT.java
index 9268973e361..cb7a22c1e0f 100644
--- a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dml/AdditionalDMLE2EIT.java
+++ b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dml/AdditionalDMLE2EIT.java
@@ -20,159 +20,179 @@ package org.apache.shardingsphere.test.e2e.engine.dml;
import org.apache.shardingsphere.test.e2e.cases.SQLCommandType;
import org.apache.shardingsphere.test.e2e.cases.SQLExecuteType;
import org.apache.shardingsphere.test.e2e.cases.value.SQLValue;
+import org.apache.shardingsphere.test.e2e.engine.SingleE2EITContainerComposer;
import org.apache.shardingsphere.test.e2e.env.runtime.IntegrationTestEnvironment;
+import org.apache.shardingsphere.test.e2e.framework.E2EITExtension;
import org.apache.shardingsphere.test.e2e.framework.param.array.E2ETestParameterFactory;
import org.apache.shardingsphere.test.e2e.framework.param.model.AssertionTestParameter;
-import org.apache.shardingsphere.test.e2e.framework.runner.ParallelRunningStrategy;
-import org.apache.shardingsphere.test.e2e.framework.runner.ParallelRunningStrategy.ParallelLevel;
-import org.junit.Ignore;
-import org.junit.Test;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.condition.EnabledIf;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.ArgumentsSource;
+import javax.xml.bind.JAXBException;
+import java.io.IOException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.ParseException;
-import java.util.Collection;
-import java.util.Collections;
+import java.util.stream.Stream;
import static org.junit.jupiter.api.Assertions.assertFalse;
-@ParallelRunningStrategy(ParallelLevel.SCENARIO)
+@ExtendWith(E2EITExtension.class)
public final class AdditionalDMLE2EIT extends BaseDMLE2EIT {
- public AdditionalDMLE2EIT(final AssertionTestParameter testParam) {
- super(testParam);
- }
-
- @Parameters(name = "{0}")
- public static Collection<AssertionTestParameter> getTestParameters() {
- if (IntegrationTestEnvironment.getInstance().isRunAdditionalTestCases()) {
- return E2ETestParameterFactory.getAssertionTestParameters(SQLCommandType.DML);
- }
- return Collections.emptyList();
- }
-
- @Test
- public void executeUpdateWithAutoGeneratedKeys() throws SQLException, ParseException {
- if (isPostgreSQLOrOpenGauss(getTestParam().getDatabaseType().getType())) {
+ @ParameterizedTest(name = "{0}")
+ @EnabledIf("isEnabled")
+ @ArgumentsSource(TestCaseArgumentsProvider.class)
+ public void executeUpdateWithAutoGeneratedKeys(final AssertionTestParameter testParam) throws SQLException, ParseException, JAXBException, IOException {
+ if (isPostgreSQLOrOpenGauss(testParam.getDatabaseType().getType())) {
return;
}
- int actualUpdateCount;
- try (Connection connection = getContainerComposer().getTargetDataSource().getConnection()) {
- actualUpdateCount = SQLExecuteType.Literal == getSqlExecuteType()
- ? executeUpdateForStatementWithAutoGeneratedKeys(connection)
- : executeUpdateForPreparedStatementWithAutoGeneratedKeys(connection);
+ try (SingleE2EITContainerComposer containerComposer = new SingleE2EITContainerComposer(testParam)) {
+ init(testParam, containerComposer);
+ int actualUpdateCount;
+ try (Connection connection = containerComposer.getContainerComposer().getTargetDataSource().getConnection()) {
+ actualUpdateCount = SQLExecuteType.Literal == containerComposer.getSqlExecuteType()
+ ? executeUpdateForStatementWithAutoGeneratedKeys(testParam, containerComposer, connection)
+ : executeUpdateForPreparedStatementWithAutoGeneratedKeys(testParam, containerComposer, connection);
+ }
+ assertDataSet(testParam, containerComposer, actualUpdateCount);
}
- assertDataSet(actualUpdateCount);
}
private boolean isPostgreSQLOrOpenGauss(final String databaseType) {
return "PostgreSQL".equals(databaseType) || "openGauss".equals(databaseType);
}
- private int executeUpdateForStatementWithAutoGeneratedKeys(final Connection connection) throws SQLException, ParseException {
+ private int executeUpdateForStatementWithAutoGeneratedKeys(final AssertionTestParameter testParam,
+ final SingleE2EITContainerComposer containerComposer, final Connection connection) throws SQLException, ParseException {
try (Statement statement = connection.createStatement()) {
- int result = statement.executeUpdate(String.format(getSQL(), getAssertion().getSQLValues().toArray()), Statement.RETURN_GENERATED_KEYS);
- assertGeneratedKeys(statement.getGeneratedKeys());
+ int result = statement.executeUpdate(String.format(containerComposer.getSQL(), containerComposer.getAssertion().getSQLValues().toArray()), Statement.RETURN_GENERATED_KEYS);
+ assertGeneratedKeys(testParam, containerComposer, statement.getGeneratedKeys());
return result;
}
}
- private int executeUpdateForPreparedStatementWithAutoGeneratedKeys(final Connection connection) throws SQLException, ParseException {
- try (PreparedStatement preparedStatement = connection.prepareStatement(getSQL(), Statement.RETURN_GENERATED_KEYS)) {
- for (SQLValue each : getAssertion().getSQLValues()) {
+ private int executeUpdateForPreparedStatementWithAutoGeneratedKeys(final AssertionTestParameter testParam,
+ final SingleE2EITContainerComposer containerComposer, final Connection connection) throws SQLException, ParseException {
+ try (PreparedStatement preparedStatement = connection.prepareStatement(containerComposer.getSQL(), Statement.RETURN_GENERATED_KEYS)) {
+ for (SQLValue each : containerComposer.getAssertion().getSQLValues()) {
preparedStatement.setObject(each.getIndex(), each.getValue());
}
int result = preparedStatement.executeUpdate();
- assertGeneratedKeys(preparedStatement.getGeneratedKeys());
+ assertGeneratedKeys(testParam, containerComposer, preparedStatement.getGeneratedKeys());
return result;
}
}
- @Test
- @Ignore
// TODO support execute update with column indexes in #23626
- public void assertExecuteUpdateWithColumnIndexes() throws SQLException, ParseException {
- if (isPostgreSQLOrOpenGauss(getTestParam().getDatabaseType().getType())) {
+ @Disabled
+ @ParameterizedTest(name = "{0}")
+ @EnabledIf("isEnabled")
+ @ArgumentsSource(TestCaseArgumentsProvider.class)
+ public void assertExecuteUpdateWithColumnIndexes(final AssertionTestParameter testParam) throws SQLException, ParseException, JAXBException, IOException {
+ if (isPostgreSQLOrOpenGauss(testParam.getDatabaseType().getType())) {
return;
}
- int actualUpdateCount;
- try (Connection connection = getContainerComposer().getTargetDataSource().getConnection()) {
- actualUpdateCount = SQLExecuteType.Literal == getSqlExecuteType() ? executeUpdateForStatementWithColumnIndexes(connection) : executeUpdateForPreparedStatementWithColumnIndexes(connection);
+ try (SingleE2EITContainerComposer containerComposer = new SingleE2EITContainerComposer(testParam)) {
+ init(testParam, containerComposer);
+ int actualUpdateCount;
+ try (Connection connection = containerComposer.getContainerComposer().getTargetDataSource().getConnection()) {
+ actualUpdateCount = SQLExecuteType.Literal == containerComposer.getSqlExecuteType()
+ ? executeUpdateForStatementWithColumnIndexes(containerComposer, connection)
+ : executeUpdateForPreparedStatementWithColumnIndexes(containerComposer, connection);
+ }
+ assertDataSet(testParam, containerComposer, actualUpdateCount);
}
- assertDataSet(actualUpdateCount);
}
- private int executeUpdateForStatementWithColumnIndexes(final Connection connection) throws SQLException, ParseException {
+ private int executeUpdateForStatementWithColumnIndexes(final SingleE2EITContainerComposer containerComposer, final Connection connection) throws SQLException, ParseException {
try (Statement statement = connection.createStatement()) {
- return statement.executeUpdate(String.format(getSQL(), getAssertion().getSQLValues().toArray()), new int[]{1});
+ return statement.executeUpdate(String.format(containerComposer.getSQL(), containerComposer.getAssertion().getSQLValues().toArray()), new int[]{1});
}
}
- private int executeUpdateForPreparedStatementWithColumnIndexes(final Connection connection) throws SQLException, ParseException {
- try (PreparedStatement preparedStatement = connection.prepareStatement(getSQL(), new int[]{1})) {
- for (SQLValue each : getAssertion().getSQLValues()) {
+ private int executeUpdateForPreparedStatementWithColumnIndexes(final SingleE2EITContainerComposer containerComposer, final Connection connection) throws SQLException, ParseException {
+ try (PreparedStatement preparedStatement = connection.prepareStatement(containerComposer.getSQL(), new int[]{1})) {
+ for (SQLValue each : containerComposer.getAssertion().getSQLValues()) {
preparedStatement.setObject(each.getIndex(), each.getValue());
}
return preparedStatement.executeUpdate();
}
}
- @Test
- @Ignore
// TODO support execute update with column names in #23626
- public void assertExecuteUpdateWithColumnNames() throws SQLException, ParseException {
- if (isPostgreSQLOrOpenGauss(getTestParam().getDatabaseType().getType())) {
+ @Disabled
+ @ParameterizedTest(name = "{0}")
+ @EnabledIf("isEnabled")
+ @ArgumentsSource(TestCaseArgumentsProvider.class)
+ public void assertExecuteUpdateWithColumnNames(final AssertionTestParameter testParam) throws SQLException, ParseException, JAXBException, IOException {
+ if (isPostgreSQLOrOpenGauss(testParam.getDatabaseType().getType())) {
return;
}
- int actualUpdateCount;
- try (Connection connection = getContainerComposer().getTargetDataSource().getConnection()) {
- actualUpdateCount = SQLExecuteType.Literal == getSqlExecuteType() ? executeUpdateForStatementWithColumnNames(connection) : executeUpdateForPreparedStatementWithColumnNames(connection);
+ try (SingleE2EITContainerComposer containerComposer = new SingleE2EITContainerComposer(testParam)) {
+ init(testParam, containerComposer);
+ int actualUpdateCount;
+ try (Connection connection = containerComposer.getContainerComposer().getTargetDataSource().getConnection()) {
+ actualUpdateCount = SQLExecuteType.Literal == containerComposer.getSqlExecuteType()
+ ? executeUpdateForStatementWithColumnNames(containerComposer, connection)
+ : executeUpdateForPreparedStatementWithColumnNames(containerComposer, connection);
+ }
+ assertDataSet(testParam, containerComposer, actualUpdateCount);
}
- assertDataSet(actualUpdateCount);
}
- private int executeUpdateForStatementWithColumnNames(final Connection connection) throws SQLException, ParseException {
+ private int executeUpdateForStatementWithColumnNames(final SingleE2EITContainerComposer containerComposer, final Connection connection) throws SQLException, ParseException {
try (Statement statement = connection.createStatement()) {
- return statement.executeUpdate(String.format(getSQL(), getAssertion().getSQLValues().toArray()));
+ return statement.executeUpdate(String.format(containerComposer.getSQL(), containerComposer.getAssertion().getSQLValues().toArray()));
}
}
- private int executeUpdateForPreparedStatementWithColumnNames(final Connection connection) throws SQLException, ParseException {
- try (PreparedStatement preparedStatement = connection.prepareStatement(getSQL(), new String[]{"TODO"})) {
- for (SQLValue each : getAssertion().getSQLValues()) {
+ private int executeUpdateForPreparedStatementWithColumnNames(final SingleE2EITContainerComposer containerComposer, final Connection connection) throws SQLException, ParseException {
+ try (PreparedStatement preparedStatement = connection.prepareStatement(containerComposer.getSQL(), new String[]{"TODO"})) {
+ for (SQLValue each : containerComposer.getAssertion().getSQLValues()) {
preparedStatement.setObject(each.getIndex(), each.getValue());
}
return preparedStatement.executeUpdate();
}
}
- @Test
- public void assertExecuteWithoutAutoGeneratedKeys() throws SQLException, ParseException {
- if (isPostgreSQLOrOpenGauss(getTestParam().getDatabaseType().getType())) {
+ @ParameterizedTest(name = "{0}")
+ @EnabledIf("isEnabled")
+ @ArgumentsSource(TestCaseArgumentsProvider.class)
+ public void assertExecuteWithoutAutoGeneratedKeys(final AssertionTestParameter testParam) throws SQLException, ParseException, JAXBException, IOException {
+ if (isPostgreSQLOrOpenGauss(testParam.getDatabaseType().getType())) {
return;
}
- int actualUpdateCount;
- try (Connection connection = getContainerComposer().getTargetDataSource().getConnection()) {
- actualUpdateCount = SQLExecuteType.Literal == getSqlExecuteType()
- ? executeForStatementWithoutAutoGeneratedKeys(connection)
- : executeForPreparedStatementWithoutAutoGeneratedKeys(connection);
+ try (SingleE2EITContainerComposer containerComposer = new SingleE2EITContainerComposer(testParam)) {
+ init(testParam, containerComposer);
+ int actualUpdateCount;
+ try (Connection connection = containerComposer.getContainerComposer().getTargetDataSource().getConnection()) {
+ actualUpdateCount = SQLExecuteType.Literal == containerComposer.getSqlExecuteType()
+ ? executeForStatementWithoutAutoGeneratedKeys(containerComposer, connection)
+ : executeForPreparedStatementWithoutAutoGeneratedKeys(containerComposer, connection);
+ }
+ assertDataSet(testParam, containerComposer, actualUpdateCount);
}
- assertDataSet(actualUpdateCount);
}
- private int executeForStatementWithoutAutoGeneratedKeys(final Connection connection) throws SQLException, ParseException {
+ private int executeForStatementWithoutAutoGeneratedKeys(final SingleE2EITContainerComposer containerComposer, final Connection connection) throws SQLException, ParseException {
try (Statement statement = connection.createStatement()) {
- assertFalse(statement.execute(String.format(getSQL(), getAssertion().getSQLValues().toArray()), Statement.NO_GENERATED_KEYS), "Not a DML statement.");
+ assertFalse(statement.execute(String.format(containerComposer.getSQL(), containerComposer.getAssertion().getSQLValues().toArray()), Statement.NO_GENERATED_KEYS), "Not a DML statement.");
return statement.getUpdateCount();
}
}
- private int executeForPreparedStatementWithoutAutoGeneratedKeys(final Connection connection) throws SQLException, ParseException {
- try (PreparedStatement preparedStatement = connection.prepareStatement(getSQL(), Statement.NO_GENERATED_KEYS)) {
- for (SQLValue each : getAssertion().getSQLValues()) {
+ private int executeForPreparedStatementWithoutAutoGeneratedKeys(final SingleE2EITContainerComposer containerComposer, final Connection connection) throws SQLException, ParseException {
+ try (PreparedStatement preparedStatement = connection.prepareStatement(containerComposer.getSQL(), Statement.NO_GENERATED_KEYS)) {
+ for (SQLValue each : containerComposer.getAssertion().getSQLValues()) {
preparedStatement.setObject(each.getIndex(), each.getValue());
}
assertFalse(preparedStatement.execute(), "Not a DML statement.");
@@ -180,61 +200,78 @@ public final class AdditionalDMLE2EIT extends BaseDMLE2EIT {
}
}
- @Test
- public void assertExecuteWithAutoGeneratedKeys() throws SQLException, ParseException {
- if (isPostgreSQLOrOpenGauss(getTestParam().getDatabaseType().getType())) {
+ @ParameterizedTest(name = "{0}")
+ @EnabledIf("isEnabled")
+ @ArgumentsSource(TestCaseArgumentsProvider.class)
+ public void assertExecuteWithAutoGeneratedKeys(final AssertionTestParameter testParam) throws SQLException, ParseException, JAXBException, IOException {
+ if (isPostgreSQLOrOpenGauss(testParam.getDatabaseType().getType())) {
return;
}
- int actualUpdateCount;
- try (Connection connection = getContainerComposer().getTargetDataSource().getConnection()) {
- actualUpdateCount = SQLExecuteType.Literal == getSqlExecuteType() ? executeForStatementWithAutoGeneratedKeys(connection) : executeForPreparedStatementWithAutoGeneratedKeys(connection);
+ try (SingleE2EITContainerComposer containerComposer = new SingleE2EITContainerComposer(testParam)) {
+ init(testParam, containerComposer);
+ int actualUpdateCount;
+ try (Connection connection = containerComposer.getContainerComposer().getTargetDataSource().getConnection()) {
+ actualUpdateCount = SQLExecuteType.Literal == containerComposer.getSqlExecuteType()
+ ? executeForStatementWithAutoGeneratedKeys(testParam, containerComposer, connection)
+ : executeForPreparedStatementWithAutoGeneratedKeys(testParam, containerComposer, connection);
+ }
+ assertDataSet(testParam, containerComposer, actualUpdateCount);
}
- assertDataSet(actualUpdateCount);
}
- private int executeForStatementWithAutoGeneratedKeys(final Connection connection) throws SQLException, ParseException {
+ private int executeForStatementWithAutoGeneratedKeys(final AssertionTestParameter testParam,
+ final SingleE2EITContainerComposer containerComposer, final Connection connection) throws SQLException, ParseException {
try (Statement statement = connection.createStatement()) {
- assertFalse(statement.execute(String.format(getSQL(), getAssertion().getSQLValues().toArray()), Statement.RETURN_GENERATED_KEYS), "Not a DML statement.");
- assertGeneratedKeys(statement.getGeneratedKeys());
+ assertFalse(statement.execute(
+ String.format(containerComposer.getSQL(), containerComposer.getAssertion().getSQLValues().toArray()), Statement.RETURN_GENERATED_KEYS), "Not a DML statement.");
+ assertGeneratedKeys(testParam, containerComposer, statement.getGeneratedKeys());
return statement.getUpdateCount();
}
}
- private int executeForPreparedStatementWithAutoGeneratedKeys(final Connection connection) throws SQLException, ParseException {
- try (PreparedStatement preparedStatement = connection.prepareStatement(getSQL(), Statement.RETURN_GENERATED_KEYS)) {
- for (SQLValue each : getAssertion().getSQLValues()) {
+ private int executeForPreparedStatementWithAutoGeneratedKeys(final AssertionTestParameter testParam,
+ final SingleE2EITContainerComposer containerComposer, final Connection connection) throws SQLException, ParseException {
+ try (PreparedStatement preparedStatement = connection.prepareStatement(containerComposer.getSQL(), Statement.RETURN_GENERATED_KEYS)) {
+ for (SQLValue each : containerComposer.getAssertion().getSQLValues()) {
preparedStatement.setObject(each.getIndex(), each.getValue());
}
assertFalse(preparedStatement.execute(), "Not a DML statement.");
- assertGeneratedKeys(preparedStatement.getGeneratedKeys());
+ assertGeneratedKeys(testParam, containerComposer, preparedStatement.getGeneratedKeys());
return preparedStatement.getUpdateCount();
}
}
- @Test
- @Ignore
// TODO support execute with column indexes in #23626
- public void assertExecuteWithColumnIndexes() throws SQLException, ParseException {
- if (isPostgreSQLOrOpenGauss(getTestParam().getDatabaseType().getType())) {
+ @Disabled
+ @ParameterizedTest(name = "{0}")
+ @EnabledIf("isEnabled")
+ @ArgumentsSource(TestCaseArgumentsProvider.class)
+ public void assertExecuteWithColumnIndexes(final AssertionTestParameter testParam) throws SQLException, ParseException, JAXBException, IOException {
+ if (isPostgreSQLOrOpenGauss(testParam.getDatabaseType().getType())) {
return;
}
- int actualUpdateCount;
- try (Connection connection = getContainerComposer().getTargetDataSource().getConnection()) {
- actualUpdateCount = SQLExecuteType.Literal == getSqlExecuteType() ? executeForStatementWithColumnIndexes(connection) : executeForPreparedStatementWithColumnIndexes(connection);
+ try (SingleE2EITContainerComposer containerComposer = new SingleE2EITContainerComposer(testParam)) {
+ init(testParam, containerComposer);
+ int actualUpdateCount;
+ try (Connection connection = containerComposer.getContainerComposer().getTargetDataSource().getConnection()) {
+ actualUpdateCount = SQLExecuteType.Literal == containerComposer.getSqlExecuteType()
+ ? executeForStatementWithColumnIndexes(containerComposer, connection)
+ : executeForPreparedStatementWithColumnIndexes(containerComposer, connection);
+ }
+ assertDataSet(testParam, containerComposer, actualUpdateCount);
}
- assertDataSet(actualUpdateCount);
}
- private int executeForStatementWithColumnIndexes(final Connection connection) throws SQLException, ParseException {
+ private int executeForStatementWithColumnIndexes(final SingleE2EITContainerComposer containerComposer, final Connection connection) throws SQLException, ParseException {
try (Statement statement = connection.createStatement()) {
- assertFalse(statement.execute(String.format(getSQL(), getAssertion().getSQLValues().toArray()), new int[]{1}), "Not a DML statement.");
+ assertFalse(statement.execute(String.format(containerComposer.getSQL(), containerComposer.getAssertion().getSQLValues().toArray()), new int[]{1}), "Not a DML statement.");
return statement.getUpdateCount();
}
}
- private int executeForPreparedStatementWithColumnIndexes(final Connection connection) throws SQLException, ParseException {
- try (PreparedStatement preparedStatement = connection.prepareStatement(getSQL(), new int[]{1})) {
- for (SQLValue each : getAssertion().getSQLValues()) {
+ private int executeForPreparedStatementWithColumnIndexes(final SingleE2EITContainerComposer containerComposer, final Connection connection) throws SQLException, ParseException {
+ try (PreparedStatement preparedStatement = connection.prepareStatement(containerComposer.getSQL(), new int[]{1})) {
+ for (SQLValue each : containerComposer.getAssertion().getSQLValues()) {
preparedStatement.setObject(each.getIndex(), each.getValue());
}
assertFalse(preparedStatement.execute(), "Not a DML statement.");
@@ -242,34 +279,53 @@ public final class AdditionalDMLE2EIT extends BaseDMLE2EIT {
}
}
- @Test
- @Ignore
// TODO support execute with column names in #23626
- public void assertExecuteWithColumnNames() throws SQLException, ParseException {
- if (isPostgreSQLOrOpenGauss(getTestParam().getDatabaseType().getType())) {
+ @Disabled
+ @ParameterizedTest(name = "{0}")
+ @EnabledIf("isEnabled")
+ @ArgumentsSource(TestCaseArgumentsProvider.class)
+ public void assertExecuteWithColumnNames(final AssertionTestParameter testParam) throws SQLException, ParseException, JAXBException, IOException {
+ if (isPostgreSQLOrOpenGauss(testParam.getDatabaseType().getType())) {
return;
}
- int actualUpdateCount;
- try (Connection connection = getContainerComposer().getTargetDataSource().getConnection()) {
- actualUpdateCount = SQLExecuteType.Literal == getSqlExecuteType() ? executeForStatementWithColumnNames(connection) : executeForPreparedStatementWithColumnNames(connection);
+ try (SingleE2EITContainerComposer containerComposer = new SingleE2EITContainerComposer(testParam)) {
+ init(testParam, containerComposer);
+ int actualUpdateCount;
+ try (Connection connection = containerComposer.getContainerComposer().getTargetDataSource().getConnection()) {
+ actualUpdateCount = SQLExecuteType.Literal == containerComposer.getSqlExecuteType()
+ ? executeForStatementWithColumnNames(containerComposer, connection)
+ : executeForPreparedStatementWithColumnNames(containerComposer, connection);
+ }
+ assertDataSet(testParam, containerComposer, actualUpdateCount);
}
- assertDataSet(actualUpdateCount);
}
- private int executeForStatementWithColumnNames(final Connection connection) throws SQLException, ParseException {
+ private int executeForStatementWithColumnNames(final SingleE2EITContainerComposer containerComposer, final Connection connection) throws SQLException, ParseException {
try (Statement statement = connection.createStatement()) {
- assertFalse(statement.execute(String.format(getSQL(), getAssertion().getSQLValues().toArray()), new String[]{"TODO"}), "Not a DML statement.");
+ assertFalse(statement.execute(String.format(containerComposer.getSQL(), containerComposer.getAssertion().getSQLValues().toArray()), new String[]{"TODO"}), "Not a DML statement.");
return statement.getUpdateCount();
}
}
- private int executeForPreparedStatementWithColumnNames(final Connection connection) throws SQLException, ParseException {
- try (PreparedStatement preparedStatement = connection.prepareStatement(getSQL(), new String[]{"TODO"})) {
- for (SQLValue each : getAssertion().getSQLValues()) {
+ private int executeForPreparedStatementWithColumnNames(final SingleE2EITContainerComposer containerComposer, final Connection connection) throws SQLException, ParseException {
+ try (PreparedStatement preparedStatement = connection.prepareStatement(containerComposer.getSQL(), new String[]{"TODO"})) {
+ for (SQLValue each : containerComposer.getAssertion().getSQLValues()) {
preparedStatement.setObject(each.getIndex(), each.getValue());
}
assertFalse(preparedStatement.execute(), "Not a DML statement.");
return preparedStatement.getUpdateCount();
}
}
+
+ private static boolean isEnabled() {
+ return E2ETestParameterFactory.containsTestParameter() && IntegrationTestEnvironment.getInstance().isRunAdditionalTestCases();
+ }
+
+ private static class TestCaseArgumentsProvider implements ArgumentsProvider {
+
+ @Override
+ public Stream<? extends Arguments> provideArguments(final ExtensionContext extensionContext) {
+ return E2ETestParameterFactory.getAssertionTestParameters(SQLCommandType.DML).stream().map(Arguments::of);
+ }
+ }
}
diff --git a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dml/BaseDMLE2EIT.java b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dml/BaseDMLE2EIT.java
index d3a4c0d0819..c87b34ddfd5 100644
--- a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dml/BaseDMLE2EIT.java
+++ b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dml/BaseDMLE2EIT.java
@@ -23,17 +23,18 @@ import org.apache.shardingsphere.test.e2e.cases.dataset.metadata.DataSetColumn;
import org.apache.shardingsphere.test.e2e.cases.dataset.metadata.DataSetMetaData;
import org.apache.shardingsphere.test.e2e.cases.dataset.row.DataSetRow;
import org.apache.shardingsphere.test.e2e.engine.E2EContainerComposer;
-import org.apache.shardingsphere.test.e2e.engine.SingleE2EIT;
+import org.apache.shardingsphere.test.e2e.engine.SingleE2EITContainerComposer;
import org.apache.shardingsphere.test.e2e.env.DataSetEnvironmentManager;
import org.apache.shardingsphere.test.e2e.env.runtime.scenario.path.ScenarioDataPath;
import org.apache.shardingsphere.test.e2e.env.runtime.scenario.path.ScenarioDataPath.Type;
import org.apache.shardingsphere.test.e2e.framework.database.DatabaseAssertionMetaData;
import org.apache.shardingsphere.test.e2e.framework.database.DatabaseAssertionMetaDataFactory;
import org.apache.shardingsphere.test.e2e.framework.param.model.AssertionTestParameter;
-import org.junit.After;
-import org.junit.Before;
+import org.junit.jupiter.api.AfterEach;
import javax.sql.DataSource;
+import javax.xml.bind.JAXBException;
+import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.sql.Connection;
import java.sql.PreparedStatement;
@@ -41,6 +42,7 @@ import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Types;
+import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Collection;
import java.util.List;
@@ -49,54 +51,61 @@ import java.util.Optional;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
-public abstract class BaseDMLE2EIT extends SingleE2EIT {
+public abstract class BaseDMLE2EIT {
private static final String DATA_COLUMN_DELIMITER = ", ";
private DataSetEnvironmentManager dataSetEnvironmentManager;
- public BaseDMLE2EIT(final AssertionTestParameter testParam) {
- super(testParam);
- }
-
- @Before
- public final void init() throws Exception {
- dataSetEnvironmentManager = new DataSetEnvironmentManager(new ScenarioDataPath(getTestParam().getScenario()).getDataSetFile(Type.ACTUAL), getContainerComposer().getActualDataSourceMap());
+ /**
+ * Init.
+ *
+ * @param testParam test parameter
+ * @param containerComposer container composer
+ * @throws SQLException SQL exception
+ * @throws ParseException parse exception
+ * @throws IOException IO exception
+ * @throws JAXBException JAXB exception
+ */
+ public final void init(final AssertionTestParameter testParam, final SingleE2EITContainerComposer containerComposer) throws SQLException, ParseException, IOException, JAXBException {
+ dataSetEnvironmentManager = new DataSetEnvironmentManager(
+ new ScenarioDataPath(testParam.getScenario()).getDataSetFile(Type.ACTUAL), containerComposer.getContainerComposer().getActualDataSourceMap());
dataSetEnvironmentManager.fillData();
}
- @After
+ @AfterEach
public final void tearDown() {
dataSetEnvironmentManager.cleanData();
}
- protected final void assertDataSet(final int actualUpdateCount) throws SQLException {
- assertThat("Only support single table for DML.", getDataSet().getMetaDataList().size(), is(1));
- assertThat(actualUpdateCount, is(getDataSet().getUpdateCount()));
- DataSetMetaData expectedDataSetMetaData = getDataSet().getMetaDataList().get(0);
+ protected final void assertDataSet(final AssertionTestParameter testParam, final SingleE2EITContainerComposer containerComposer, final int actualUpdateCount) throws SQLException {
+ assertThat("Only support single table for DML.", containerComposer.getDataSet().getMetaDataList().size(), is(1));
+ assertThat(actualUpdateCount, is(containerComposer.getDataSet().getUpdateCount()));
+ DataSetMetaData expectedDataSetMetaData = containerComposer.getDataSet().getMetaDataList().get(0);
for (String each : new InlineExpressionParser(expectedDataSetMetaData.getDataNodes()).splitAndEvaluate()) {
DataNode dataNode = new DataNode(each);
- DataSource dataSource = getContainerComposer().getActualDataSourceMap().get(dataNode.getDataSourceName());
+ DataSource dataSource = containerComposer.getContainerComposer().getActualDataSourceMap().get(dataNode.getDataSourceName());
try (
Connection connection = dataSource.getConnection();
- PreparedStatement preparedStatement = connection.prepareStatement(generateFetchActualDataSQL(dataNode))) {
- assertDataSet(preparedStatement, expectedDataSetMetaData, getDataSet().findRows(dataNode));
+ PreparedStatement preparedStatement = connection.prepareStatement(generateFetchActualDataSQL(testParam, containerComposer, dataNode))) {
+ assertDataSet(testParam, preparedStatement, expectedDataSetMetaData, containerComposer.getDataSet().findRows(dataNode));
}
}
}
- private void assertDataSet(final PreparedStatement actualPreparedStatement, final DataSetMetaData expectedDataSetMetaData, final List<DataSetRow> expectedDataSetRows) throws SQLException {
+ private void assertDataSet(final AssertionTestParameter testParam,
+ final PreparedStatement actualPreparedStatement, final DataSetMetaData expectedDataSetMetaData, final List<DataSetRow> expectedDataSetRows) throws SQLException {
try (ResultSet actualResultSet = actualPreparedStatement.executeQuery()) {
assertMetaData(actualResultSet.getMetaData(), expectedDataSetMetaData.getColumns());
- assertRows(actualResultSet, expectedDataSetRows);
+ assertRows(testParam, actualResultSet, expectedDataSetRows);
}
}
- private String generateFetchActualDataSQL(final DataNode dataNode) throws SQLException {
- Optional<DatabaseAssertionMetaData> databaseAssertionMetaData = DatabaseAssertionMetaDataFactory.newInstance(getTestParam().getDatabaseType());
+ private String generateFetchActualDataSQL(final AssertionTestParameter testParam, final SingleE2EITContainerComposer containerComposer, final DataNode dataNode) throws SQLException {
+ Optional<DatabaseAssertionMetaData> databaseAssertionMetaData = DatabaseAssertionMetaDataFactory.newInstance(testParam.getDatabaseType());
if (databaseAssertionMetaData.isPresent()) {
String primaryKeyColumnName = databaseAssertionMetaData.get().getPrimaryKeyColumnName(
- getContainerComposer().getActualDataSourceMap().get(dataNode.getDataSourceName()), dataNode.getTableName());
+ containerComposer.getContainerComposer().getActualDataSourceMap().get(dataNode.getDataSourceName()), dataNode.getTableName());
return String.format("SELECT * FROM %s ORDER BY %s ASC", dataNode.getTableName(), primaryKeyColumnName);
}
return String.format("SELECT * FROM %s", dataNode.getTableName());
@@ -110,12 +119,12 @@ public abstract class BaseDMLE2EIT extends SingleE2EIT {
}
}
- private void assertRows(final ResultSet actual, final List<DataSetRow> expected) throws SQLException {
+ private void assertRows(final AssertionTestParameter testParam, final ResultSet actual, final List<DataSetRow> expected) throws SQLException {
int rowCount = 0;
while (actual.next()) {
int columnIndex = 1;
for (String each : expected.get(rowCount).splitValues(DATA_COLUMN_DELIMITER)) {
- assertValue(actual, columnIndex, each);
+ assertValue(testParam, actual, columnIndex, each);
columnIndex++;
}
rowCount++;
@@ -123,15 +132,15 @@ public abstract class BaseDMLE2EIT extends SingleE2EIT {
assertThat("Size of actual result set is different with size of expected dat set rows.", rowCount, is(expected.size()));
}
- private void assertValue(final ResultSet actual, final int columnIndex, final String expected) throws SQLException {
+ private void assertValue(final AssertionTestParameter testParam, final ResultSet actual, final int columnIndex, final String expected) throws SQLException {
if (Types.DATE == actual.getMetaData().getColumnType(columnIndex)) {
if (!E2EContainerComposer.NOT_VERIFY_FLAG.equals(expected)) {
assertThat(new SimpleDateFormat("yyyy-MM-dd").format(actual.getDate(columnIndex)), is(expected));
}
} else if (Types.CHAR == actual.getMetaData().getColumnType(columnIndex)
- && ("PostgreSQL".equals(getTestParam().getDatabaseType().getType()) || "openGauss".equals(getTestParam().getDatabaseType().getType()))) {
+ && ("PostgreSQL".equals(testParam.getDatabaseType().getType()) || "openGauss".equals(testParam.getDatabaseType().getType()))) {
assertThat(String.valueOf(actual.getObject(columnIndex)).trim(), is(expected));
- } else if (isPostgreSQLOrOpenGaussMoney(actual.getMetaData().getColumnTypeName(columnIndex))) {
+ } else if (isPostgreSQLOrOpenGaussMoney(testParam, actual.getMetaData().getColumnTypeName(columnIndex))) {
assertThat(actual.getString(columnIndex), is(expected));
} else if (Types.BINARY == actual.getMetaData().getColumnType(columnIndex)) {
assertThat(actual.getObject(columnIndex), is(expected.getBytes(StandardCharsets.UTF_8)));
@@ -140,16 +149,16 @@ public abstract class BaseDMLE2EIT extends SingleE2EIT {
}
}
- private boolean isPostgreSQLOrOpenGaussMoney(final String columnTypeName) {
- return "money".equalsIgnoreCase(columnTypeName) && ("PostgreSQL".equals(getTestParam().getDatabaseType().getType()) || "openGauss".equals(getTestParam().getDatabaseType().getType()));
+ private boolean isPostgreSQLOrOpenGaussMoney(final AssertionTestParameter testParam, final String columnTypeName) {
+ return "money".equalsIgnoreCase(columnTypeName) && ("PostgreSQL".equals(testParam.getDatabaseType().getType()) || "openGauss".equals(testParam.getDatabaseType().getType()));
}
- protected void assertGeneratedKeys(final ResultSet generatedKeys) throws SQLException {
- if (null == getGeneratedKeyDataSet()) {
+ protected void assertGeneratedKeys(final AssertionTestParameter testParam, final SingleE2EITContainerComposer containerComposer, final ResultSet generatedKeys) throws SQLException {
+ if (null == containerComposer.getGeneratedKeyDataSet()) {
return;
}
- assertThat("Only support single table for DML.", getGeneratedKeyDataSet().getMetaDataList().size(), is(1));
- assertMetaData(generatedKeys.getMetaData(), getGeneratedKeyDataSet().getMetaDataList().get(0).getColumns());
- assertRows(generatedKeys, getGeneratedKeyDataSet().getRows());
+ assertThat("Only support single table for DML.", containerComposer.getGeneratedKeyDataSet().getMetaDataList().size(), is(1));
+ assertMetaData(generatedKeys.getMetaData(), containerComposer.getGeneratedKeyDataSet().getMetaDataList().get(0).getColumns());
+ assertRows(testParam, generatedKeys, containerComposer.getGeneratedKeyDataSet().getRows());
}
}
diff --git a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dml/GeneralDMLE2EIT.java b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dml/GeneralDMLE2EIT.java
index 84c91f467fc..f1b693180ba 100644
--- a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dml/GeneralDMLE2EIT.java
+++ b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dml/GeneralDMLE2EIT.java
@@ -20,81 +20,105 @@ package org.apache.shardingsphere.test.e2e.engine.dml;
import org.apache.shardingsphere.test.e2e.cases.SQLCommandType;
import org.apache.shardingsphere.test.e2e.cases.SQLExecuteType;
import org.apache.shardingsphere.test.e2e.cases.value.SQLValue;
+import org.apache.shardingsphere.test.e2e.engine.SingleE2EITContainerComposer;
+import org.apache.shardingsphere.test.e2e.framework.E2EITExtension;
import org.apache.shardingsphere.test.e2e.framework.param.array.E2ETestParameterFactory;
import org.apache.shardingsphere.test.e2e.framework.param.model.AssertionTestParameter;
-import org.apache.shardingsphere.test.e2e.framework.runner.ParallelRunningStrategy;
-import org.apache.shardingsphere.test.e2e.framework.runner.ParallelRunningStrategy.ParallelLevel;
-import org.junit.Test;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.api.condition.EnabledIf;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.ArgumentsSource;
+import javax.xml.bind.JAXBException;
+import java.io.IOException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.ParseException;
-import java.util.Collection;
+import java.util.stream.Stream;
import static org.junit.jupiter.api.Assertions.assertFalse;
-@ParallelRunningStrategy(ParallelLevel.SCENARIO)
+@ExtendWith(E2EITExtension.class)
public final class GeneralDMLE2EIT extends BaseDMLE2EIT {
- public GeneralDMLE2EIT(final AssertionTestParameter testParam) {
- super(testParam);
- }
-
- @Parameters(name = "{0}")
- public static Collection<AssertionTestParameter> getTestParameters() {
- return E2ETestParameterFactory.getAssertionTestParameters(SQLCommandType.DML);
- }
-
- @Test
- public void assertExecuteUpdate() throws SQLException, ParseException {
- int actualUpdateCount;
- try (Connection connection = getContainerComposer().getTargetDataSource().getConnection()) {
- actualUpdateCount = SQLExecuteType.Literal == getSqlExecuteType() ? executeUpdateForStatement(connection) : executeUpdateForPreparedStatement(connection);
+ @ParameterizedTest(name = "{0}")
+ @EnabledIf("isEnabled")
+ @ArgumentsSource(TestCaseArgumentsProvider.class)
+ public void assertExecuteUpdate(final AssertionTestParameter testParam) throws SQLException, ParseException, JAXBException, IOException {
+ try (SingleE2EITContainerComposer containerComposer = new SingleE2EITContainerComposer(testParam)) {
+ init(testParam, containerComposer);
+ int actualUpdateCount;
+ try (Connection connection = containerComposer.getContainerComposer().getTargetDataSource().getConnection()) {
+ actualUpdateCount = SQLExecuteType.Literal == containerComposer.getSqlExecuteType()
+ ? executeUpdateForStatement(containerComposer, connection)
+ : executeUpdateForPreparedStatement(containerComposer, connection);
+ }
+ assertDataSet(testParam, containerComposer, actualUpdateCount);
}
- assertDataSet(actualUpdateCount);
}
- private int executeUpdateForStatement(final Connection connection) throws SQLException, ParseException {
+ private int executeUpdateForStatement(final SingleE2EITContainerComposer containerComposer, final Connection connection) throws SQLException, ParseException {
try (Statement statement = connection.createStatement()) {
- return statement.executeUpdate(getSQL());
+ return statement.executeUpdate(containerComposer.getSQL());
}
}
- private int executeUpdateForPreparedStatement(final Connection connection) throws SQLException, ParseException {
- try (PreparedStatement preparedStatement = connection.prepareStatement(getSQL())) {
- for (SQLValue each : getAssertion().getSQLValues()) {
+ private int executeUpdateForPreparedStatement(final SingleE2EITContainerComposer containerComposer, final Connection connection) throws SQLException, ParseException {
+ try (PreparedStatement preparedStatement = connection.prepareStatement(containerComposer.getSQL())) {
+ for (SQLValue each : containerComposer.getAssertion().getSQLValues()) {
preparedStatement.setObject(each.getIndex(), each.getValue());
}
return preparedStatement.executeUpdate();
}
}
- @Test
- public void assertExecute() throws SQLException, ParseException {
- int actualUpdateCount;
- try (Connection connection = getContainerComposer().getTargetDataSource().getConnection()) {
- actualUpdateCount = SQLExecuteType.Literal == getSqlExecuteType() ? executeForStatement(connection) : executeForPreparedStatement(connection);
+ @ParameterizedTest(name = "{0}")
+ @EnabledIf("isEnabled")
+ @ArgumentsSource(TestCaseArgumentsProvider.class)
+ public void assertExecute(final AssertionTestParameter testParam) throws SQLException, ParseException, JAXBException, IOException {
+ try (SingleE2EITContainerComposer containerComposer = new SingleE2EITContainerComposer(testParam)) {
+ init(testParam, containerComposer);
+ int actualUpdateCount;
+ try (Connection connection = containerComposer.getContainerComposer().getTargetDataSource().getConnection()) {
+ actualUpdateCount = SQLExecuteType.Literal == containerComposer.getSqlExecuteType()
+ ? executeForStatement(containerComposer, connection)
+ : executeForPreparedStatement(containerComposer, connection);
+ }
+ assertDataSet(testParam, containerComposer, actualUpdateCount);
}
- assertDataSet(actualUpdateCount);
}
- private int executeForStatement(final Connection connection) throws SQLException, ParseException {
+ private int executeForStatement(final SingleE2EITContainerComposer containerComposer, final Connection connection) throws SQLException, ParseException {
try (Statement statement = connection.createStatement()) {
- assertFalse(statement.execute(getSQL()), "Not a DML statement.");
+ assertFalse(statement.execute(containerComposer.getSQL()), "Not a DML statement.");
return statement.getUpdateCount();
}
}
- private int executeForPreparedStatement(final Connection connection) throws SQLException, ParseException {
- try (PreparedStatement preparedStatement = connection.prepareStatement(getSQL())) {
- for (SQLValue each : getAssertion().getSQLValues()) {
+ private int executeForPreparedStatement(final SingleE2EITContainerComposer containerComposer, final Connection connection) throws SQLException, ParseException {
+ try (PreparedStatement preparedStatement = connection.prepareStatement(containerComposer.getSQL())) {
+ for (SQLValue each : containerComposer.getAssertion().getSQLValues()) {
preparedStatement.setObject(each.getIndex(), each.getValue());
}
assertFalse(preparedStatement.execute(), "Not a DML statement.");
return preparedStatement.getUpdateCount();
}
}
+
+ private static boolean isEnabled() {
+ return E2ETestParameterFactory.containsTestParameter();
+ }
+
+ private static class TestCaseArgumentsProvider implements ArgumentsProvider {
+
+ @Override
+ public Stream<? extends Arguments> provideArguments(final ExtensionContext extensionContext) {
+ return E2ETestParameterFactory.getAssertionTestParameters(SQLCommandType.DML).stream().map(Arguments::of);
+ }
+ }
}
diff --git a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dql/AdditionalDQLE2EIT.java b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dql/AdditionalDQLE2EIT.java
index ae24b5ade8c..e715c2479b7 100644
--- a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dql/AdditionalDQLE2EIT.java
+++ b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dql/AdditionalDQLE2EIT.java
@@ -20,86 +20,104 @@ package org.apache.shardingsphere.test.e2e.engine.dql;
import org.apache.shardingsphere.test.e2e.cases.SQLCommandType;
import org.apache.shardingsphere.test.e2e.cases.SQLExecuteType;
import org.apache.shardingsphere.test.e2e.cases.value.SQLValue;
+import org.apache.shardingsphere.test.e2e.engine.SingleE2EITContainerComposer;
import org.apache.shardingsphere.test.e2e.env.runtime.IntegrationTestEnvironment;
+import org.apache.shardingsphere.test.e2e.framework.E2EITExtension;
import org.apache.shardingsphere.test.e2e.framework.param.array.E2ETestParameterFactory;
import org.apache.shardingsphere.test.e2e.framework.param.model.AssertionTestParameter;
-import org.apache.shardingsphere.test.e2e.framework.runner.ParallelRunningStrategy;
-import org.apache.shardingsphere.test.e2e.framework.runner.ParallelRunningStrategy.ParallelLevel;
-import org.junit.Test;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.api.condition.EnabledIf;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.ArgumentsSource;
+import javax.xml.bind.JAXBException;
+import java.io.IOException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.ParseException;
-import java.util.Collection;
-import java.util.Collections;
+import java.util.stream.Stream;
import static org.junit.jupiter.api.Assertions.assertTrue;
-@ParallelRunningStrategy(ParallelLevel.CASE)
+@ExtendWith(E2EITExtension.class)
public final class AdditionalDQLE2EIT extends BaseDQLE2EIT {
- public AdditionalDQLE2EIT(final AssertionTestParameter testParam) {
- super(testParam);
- }
-
- @Parameters(name = "{0}")
- public static Collection<AssertionTestParameter> getTestParameters() {
- return IntegrationTestEnvironment.getInstance().isRunAdditionalTestCases() ? E2ETestParameterFactory.getAssertionTestParameters(SQLCommandType.DQL) : Collections.emptyList();
- }
-
- @Test
- public void assertExecuteQueryWithResultSetTypeAndResultSetConcurrency() throws SQLException, ParseException {
- // TODO fix e2e test blocked exception with PostgreSQL or openGuass in #23643
- if (isPostgreSQLOrOpenGauss(getTestParam().getDatabaseType().getType())) {
- return;
- }
- if (isUseXMLAsExpectedDataset()) {
- assertExecuteQueryWithXMLExpected(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
- } else {
- assertExecuteQueryWithExpectedDataSource(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
+ @ParameterizedTest(name = "{0}")
+ @EnabledIf("isEnabled")
+ @ArgumentsSource(TestCaseArgumentsProvider.class)
+ public void assertExecuteQueryWithResultSetTypeAndResultSetConcurrency(final AssertionTestParameter testParam) throws SQLException, ParseException, JAXBException, IOException {
+ try (SingleE2EITContainerComposer containerComposer = new SingleE2EITContainerComposer(testParam)) {
+ init(testParam, containerComposer);
+ // TODO fix e2e test blocked exception with PostgreSQL or openGuass in #23643
+ if (isPostgreSQLOrOpenGauss(testParam.getDatabaseType().getType())) {
+ return;
+ }
+ if (isUseXMLAsExpectedDataset()) {
+ assertExecuteQueryWithXMLExpected(testParam, containerComposer, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
+ } else {
+ assertExecuteQueryWithExpectedDataSource(containerComposer, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
+ }
}
}
- @Test
- public void assertExecuteQueryWithResultSetTypeAndResultSetConcurrencyAndResultSetHoldability() throws SQLException, ParseException {
- // TODO fix e2e test blocked exception with PostgreSQL or openGuass in #23643
- if (isPostgreSQLOrOpenGauss(getTestParam().getDatabaseType().getType())) {
- return;
- }
- if (isUseXMLAsExpectedDataset()) {
- assertExecuteQueryWithXMLExpected(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT);
- } else {
- assertExecuteQueryWithExpectedDataSource(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT);
+ @ParameterizedTest(name = "{0}")
+ @EnabledIf("isEnabled")
+ @ArgumentsSource(TestCaseArgumentsProvider.class)
+ public void assertExecuteQueryWithResultSetTypeAndResultSetConcurrencyAndResultSetHoldability(final AssertionTestParameter testParam)
+ throws SQLException, ParseException, JAXBException, IOException {
+ try (SingleE2EITContainerComposer containerComposer = new SingleE2EITContainerComposer(testParam)) {
+ init(testParam, containerComposer);
+ // TODO fix e2e test blocked exception with PostgreSQL or openGuass in #23643
+ if (isPostgreSQLOrOpenGauss(testParam.getDatabaseType().getType())) {
+ return;
+ }
+ if (isUseXMLAsExpectedDataset()) {
+ assertExecuteQueryWithXMLExpected(testParam, containerComposer, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT);
+ } else {
+ assertExecuteQueryWithExpectedDataSource(containerComposer, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT);
+ }
}
}
- @Test
- public void assertExecuteWithResultSetTypeAndResultSetConcurrency() throws SQLException, ParseException {
- // TODO fix e2e test blocked exception with PostgreSQL or openGuass in #23643
- if (isPostgreSQLOrOpenGauss(getTestParam().getDatabaseType().getType())) {
- return;
- }
- if (isUseXMLAsExpectedDataset()) {
- assertExecuteWithXMLExpected(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
- } else {
- assertExecuteWithExpectedDataSource(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
+ @ParameterizedTest(name = "{0}")
+ @EnabledIf("isEnabled")
+ @ArgumentsSource(TestCaseArgumentsProvider.class)
+ public void assertExecuteWithResultSetTypeAndResultSetConcurrency(final AssertionTestParameter testParam) throws SQLException, ParseException, JAXBException, IOException {
+ try (SingleE2EITContainerComposer containerComposer = new SingleE2EITContainerComposer(testParam)) {
+ init(testParam, containerComposer);
+ // TODO fix e2e test blocked exception with PostgreSQL or openGuass in #23643
+ if (isPostgreSQLOrOpenGauss(testParam.getDatabaseType().getType())) {
+ return;
+ }
+ if (isUseXMLAsExpectedDataset()) {
+ assertExecuteWithXMLExpected(testParam, containerComposer, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
+ } else {
+ assertExecuteWithExpectedDataSource(containerComposer, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
+ }
}
}
- @Test
- public void assertExecuteWithResultSetTypeAndResultSetConcurrencyAndResultSetHoldability() throws SQLException, ParseException {
- // TODO fix e2e test blocked exception with PostgreSQL or openGuass in #23643
- if (isPostgreSQLOrOpenGauss(getTestParam().getDatabaseType().getType())) {
- return;
- }
- if (isUseXMLAsExpectedDataset()) {
- assertExecuteWithXMLExpected(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT);
- } else {
- assertExecuteWithExpectedDataSource(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT);
+ @ParameterizedTest(name = "{0}")
+ @EnabledIf("isEnabled")
+ @ArgumentsSource(TestCaseArgumentsProvider.class)
+ public void assertExecuteWithResultSetTypeAndResultSetConcurrencyAndResultSetHoldability(final AssertionTestParameter testParam) throws SQLException, ParseException, JAXBException, IOException {
+ try (SingleE2EITContainerComposer containerComposer = new SingleE2EITContainerComposer(testParam)) {
+ init(testParam, containerComposer);
+ // TODO fix e2e test blocked exception with PostgreSQL or openGuass in #23643
+ if (isPostgreSQLOrOpenGauss(testParam.getDatabaseType().getType())) {
+ return;
+ }
+ if (isUseXMLAsExpectedDataset()) {
+ assertExecuteWithXMLExpected(testParam, containerComposer, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT);
+ } else {
+ assertExecuteWithExpectedDataSource(containerComposer, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT);
+ }
}
}
@@ -107,54 +125,55 @@ public final class AdditionalDQLE2EIT extends BaseDQLE2EIT {
return "PostgreSQL".equals(databaseType) || "openGauss".equals(databaseType);
}
- private void assertExecuteQueryWithXMLExpected(final int... resultSetTypes) throws SQLException, ParseException {
+ private void assertExecuteQueryWithXMLExpected(final AssertionTestParameter testParam,
+ final SingleE2EITContainerComposer containerComposer, final int... resultSetTypes) throws SQLException, ParseException {
// TODO Fix jdbc adapter
- if ("jdbc".equals(getAdapter())) {
+ if ("jdbc".equals(testParam.getAdapter())) {
return;
}
try (
- Connection connection = getContainerComposer().getTargetDataSource().getConnection();
+ Connection connection = containerComposer.getContainerComposer().getTargetDataSource().getConnection();
Statement statement = 2 == resultSetTypes.length ? connection.createStatement(resultSetTypes[0], resultSetTypes[1])
: connection.createStatement(resultSetTypes[0], resultSetTypes[1], resultSetTypes[2]);
- ResultSet resultSet = statement.executeQuery(getSQL())) {
- assertResultSet(resultSet);
+ ResultSet resultSet = statement.executeQuery(containerComposer.getSQL())) {
+ assertResultSet(containerComposer, resultSet);
}
}
- private void assertExecuteQueryWithExpectedDataSource(final int... resultSetTypes) throws SQLException, ParseException {
+ private void assertExecuteQueryWithExpectedDataSource(final SingleE2EITContainerComposer containerComposer, final int... resultSetTypes) throws SQLException, ParseException {
try (
- Connection actualConnection = getContainerComposer().getTargetDataSource().getConnection();
+ Connection actualConnection = containerComposer.getContainerComposer().getTargetDataSource().getConnection();
Connection expectedConnection = getExpectedDataSource().getConnection()) {
- if (SQLExecuteType.Literal == getSqlExecuteType()) {
- assertExecuteQueryForStatementWithResultSetTypes(actualConnection, expectedConnection, resultSetTypes);
+ if (SQLExecuteType.Literal == containerComposer.getSqlExecuteType()) {
+ assertExecuteQueryForStatementWithResultSetTypes(containerComposer, actualConnection, expectedConnection, resultSetTypes);
} else {
- assertExecuteQueryForPreparedStatementWithResultSetTypes(actualConnection, expectedConnection, resultSetTypes);
+ assertExecuteQueryForPreparedStatementWithResultSetTypes(containerComposer, actualConnection, expectedConnection, resultSetTypes);
}
}
}
- private void assertExecuteQueryForStatementWithResultSetTypes(
+ private void assertExecuteQueryForStatementWithResultSetTypes(final SingleE2EITContainerComposer containerComposer,
final Connection actualConnection, final Connection expectedConnection,
final int... resultSetTypes) throws SQLException, ParseException {
try (
Statement actualStatement = 2 == resultSetTypes.length ? actualConnection.createStatement(resultSetTypes[0], resultSetTypes[1])
: actualConnection.createStatement(resultSetTypes[0], resultSetTypes[1], resultSetTypes[2]);
- ResultSet actualResultSet = actualStatement.executeQuery(getSQL());
+ ResultSet actualResultSet = actualStatement.executeQuery(containerComposer.getSQL());
Statement expectedStatement = 2 == resultSetTypes.length ? expectedConnection.createStatement(resultSetTypes[0], resultSetTypes[1])
: expectedConnection.createStatement(resultSetTypes[0], resultSetTypes[1], resultSetTypes[2]);
- ResultSet expectedResultSet = expectedStatement.executeQuery(getSQL())) {
+ ResultSet expectedResultSet = expectedStatement.executeQuery(containerComposer.getSQL())) {
assertResultSet(actualResultSet, expectedResultSet);
}
}
- private void assertExecuteQueryForPreparedStatementWithResultSetTypes(final Connection actualConnection, final Connection expectedConnection,
+ private void assertExecuteQueryForPreparedStatementWithResultSetTypes(final SingleE2EITContainerComposer containerComposer, final Connection actualConnection, final Connection expectedConnection,
final int... resultSetTypes) throws SQLException, ParseException {
try (
- PreparedStatement actualPreparedStatement = 2 == resultSetTypes.length ? actualConnection.prepareStatement(getSQL(), resultSetTypes[0], resultSetTypes[1])
- : actualConnection.prepareStatement(getSQL(), resultSetTypes[0], resultSetTypes[1], resultSetTypes[2]);
- PreparedStatement expectedPreparedStatement = 2 == resultSetTypes.length ? expectedConnection.prepareStatement(getSQL(), resultSetTypes[0], resultSetTypes[1])
- : expectedConnection.prepareStatement(getSQL(), resultSetTypes[0], resultSetTypes[1], resultSetTypes[2])) {
- for (SQLValue each : getAssertion().getSQLValues()) {
+ PreparedStatement actualPreparedStatement = 2 == resultSetTypes.length ? actualConnection.prepareStatement(containerComposer.getSQL(), resultSetTypes[0], resultSetTypes[1])
+ : actualConnection.prepareStatement(containerComposer.getSQL(), resultSetTypes[0], resultSetTypes[1], resultSetTypes[2]);
+ PreparedStatement expectedPreparedStatement = 2 == resultSetTypes.length ? expectedConnection.prepareStatement(containerComposer.getSQL(), resultSetTypes[0], resultSetTypes[1])
+ : expectedConnection.prepareStatement(containerComposer.getSQL(), resultSetTypes[0], resultSetTypes[1], resultSetTypes[2])) {
+ for (SQLValue each : containerComposer.getAssertion().getSQLValues()) {
actualPreparedStatement.setObject(each.getIndex(), each.getValue());
expectedPreparedStatement.setObject(each.getIndex(), each.getValue());
}
@@ -166,41 +185,42 @@ public final class AdditionalDQLE2EIT extends BaseDQLE2EIT {
}
}
- private void assertExecuteWithXMLExpected(final int... resultSetTypes) throws SQLException, ParseException {
+ private void assertExecuteWithXMLExpected(final AssertionTestParameter testParam,
+ final SingleE2EITContainerComposer containerComposer, final int... resultSetTypes) throws SQLException, ParseException {
// TODO Fix jdbc adapter
- if ("jdbc".equals(getAdapter())) {
+ if ("jdbc".equals(testParam.getAdapter())) {
return;
}
try (
- Connection connection = getContainerComposer().getTargetDataSource().getConnection();
+ Connection connection = containerComposer.getContainerComposer().getTargetDataSource().getConnection();
Statement statement = 2 == resultSetTypes.length ? connection.createStatement(resultSetTypes[0], resultSetTypes[1])
: connection.createStatement(resultSetTypes[0], resultSetTypes[1], resultSetTypes[2])) {
- assertTrue(statement.execute(getSQL()), "Not a query statement.");
+ assertTrue(statement.execute(containerComposer.getSQL()), "Not a query statement.");
ResultSet resultSet = statement.getResultSet();
- assertResultSet(resultSet);
+ assertResultSet(containerComposer, resultSet);
}
}
- private void assertExecuteWithExpectedDataSource(final int... resultSetTypes) throws SQLException, ParseException {
+ private void assertExecuteWithExpectedDataSource(final SingleE2EITContainerComposer containerComposer, final int... resultSetTypes) throws SQLException, ParseException {
try (
- Connection actualConnection = getContainerComposer().getTargetDataSource().getConnection();
+ Connection actualConnection = containerComposer.getContainerComposer().getTargetDataSource().getConnection();
Connection expectedConnection = getExpectedDataSource().getConnection()) {
- if (SQLExecuteType.Literal == getSqlExecuteType()) {
- assertExecuteForStatementWithResultSetTypes(actualConnection, expectedConnection, resultSetTypes);
+ if (SQLExecuteType.Literal == containerComposer.getSqlExecuteType()) {
+ assertExecuteForStatementWithResultSetTypes(containerComposer, actualConnection, expectedConnection, resultSetTypes);
} else {
- assertExecuteForPreparedStatementWithResultSetTypes(actualConnection, expectedConnection, resultSetTypes);
+ assertExecuteForPreparedStatementWithResultSetTypes(containerComposer, actualConnection, expectedConnection, resultSetTypes);
}
}
}
- private void assertExecuteForStatementWithResultSetTypes(
+ private void assertExecuteForStatementWithResultSetTypes(final SingleE2EITContainerComposer containerComposer,
final Connection actualConnection, final Connection expectedConnection, final int... resultSetTypes) throws SQLException, ParseException {
try (
Statement actualStatement = 2 == resultSetTypes.length ? actualConnection.createStatement(resultSetTypes[0], resultSetTypes[1])
: actualConnection.createStatement(resultSetTypes[0], resultSetTypes[1], resultSetTypes[2]);
Statement expectedStatement = 2 == resultSetTypes.length ? expectedConnection.createStatement(resultSetTypes[0], resultSetTypes[1])
: expectedConnection.createStatement(resultSetTypes[0], resultSetTypes[1], resultSetTypes[2])) {
- assertTrue(actualStatement.execute(getSQL()) && expectedStatement.execute(getSQL()), "Not a query statement.");
+ assertTrue(actualStatement.execute(containerComposer.getSQL()) && expectedStatement.execute(containerComposer.getSQL()), "Not a query statement.");
try (
ResultSet actualResultSet = actualStatement.getResultSet();
ResultSet expectedResultSet = expectedStatement.getResultSet()) {
@@ -209,14 +229,14 @@ public final class AdditionalDQLE2EIT extends BaseDQLE2EIT {
}
}
- private void assertExecuteForPreparedStatementWithResultSetTypes(final Connection actualConnection, final Connection expectedConnection,
+ private void assertExecuteForPreparedStatementWithResultSetTypes(final SingleE2EITContainerComposer containerComposer, final Connection actualConnection, final Connection expectedConnection,
final int... resultSetTypes) throws SQLException, ParseException {
try (
- PreparedStatement actualPreparedStatement = 2 == resultSetTypes.length ? actualConnection.prepareStatement(getSQL(), resultSetTypes[0], resultSetTypes[1])
- : actualConnection.prepareStatement(getSQL(), resultSetTypes[0], resultSetTypes[1], resultSetTypes[2]);
- PreparedStatement expectedPreparedStatement = 2 == resultSetTypes.length ? expectedConnection.prepareStatement(getSQL(), resultSetTypes[0], resultSetTypes[1])
- : expectedConnection.prepareStatement(getSQL(), resultSetTypes[0], resultSetTypes[1], resultSetTypes[2])) {
- for (SQLValue each : getAssertion().getSQLValues()) {
+ PreparedStatement actualPreparedStatement = 2 == resultSetTypes.length ? actualConnection.prepareStatement(containerComposer.getSQL(), resultSetTypes[0], resultSetTypes[1])
+ : actualConnection.prepareStatement(containerComposer.getSQL(), resultSetTypes[0], resultSetTypes[1], resultSetTypes[2]);
+ PreparedStatement expectedPreparedStatement = 2 == resultSetTypes.length ? expectedConnection.prepareStatement(containerComposer.getSQL(), resultSetTypes[0], resultSetTypes[1])
+ : expectedConnection.prepareStatement(containerComposer.getSQL(), resultSetTypes[0], resultSetTypes[1], resultSetTypes[2])) {
+ for (SQLValue each : containerComposer.getAssertion().getSQLValues()) {
actualPreparedStatement.setObject(each.getIndex(), each.getValue());
expectedPreparedStatement.setObject(each.getIndex(), each.getValue());
}
@@ -228,4 +248,16 @@ public final class AdditionalDQLE2EIT extends BaseDQLE2EIT {
}
}
}
+
+ private static boolean isEnabled() {
+ return E2ETestParameterFactory.containsTestParameter() && IntegrationTestEnvironment.getInstance().isRunAdditionalTestCases();
+ }
+
+ private static class TestCaseArgumentsProvider implements ArgumentsProvider {
+
+ @Override
+ public Stream<? extends Arguments> provideArguments(final ExtensionContext extensionContext) {
+ return E2ETestParameterFactory.getAssertionTestParameters(SQLCommandType.DQL).stream().map(Arguments::of);
+ }
+ }
}
diff --git a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dql/BaseDQLE2EIT.java b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dql/BaseDQLE2EIT.java
index 9e646c3c33a..594cd47777d 100644
--- a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dql/BaseDQLE2EIT.java
+++ b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dql/BaseDQLE2EIT.java
@@ -22,12 +22,11 @@ import lombok.Getter;
import org.apache.shardingsphere.test.e2e.cases.dataset.metadata.DataSetColumn;
import org.apache.shardingsphere.test.e2e.cases.dataset.metadata.DataSetMetaData;
import org.apache.shardingsphere.test.e2e.cases.dataset.row.DataSetRow;
-import org.apache.shardingsphere.test.e2e.engine.SingleE2EIT;
+import org.apache.shardingsphere.test.e2e.engine.SingleE2EITContainerComposer;
import org.apache.shardingsphere.test.e2e.env.DataSetEnvironmentManager;
import org.apache.shardingsphere.test.e2e.env.runtime.scenario.path.ScenarioDataPath;
import org.apache.shardingsphere.test.e2e.env.runtime.scenario.path.ScenarioDataPath.Type;
import org.apache.shardingsphere.test.e2e.framework.param.model.AssertionTestParameter;
-import org.junit.Before;
import javax.sql.DataSource;
import javax.xml.bind.JAXBException;
@@ -49,7 +48,7 @@ import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
@Getter(AccessLevel.PROTECTED)
-public abstract class BaseDQLE2EIT extends SingleE2EIT {
+public abstract class BaseDQLE2EIT {
private static final Collection<String> FILLED_SUITES = new HashSet<>();
@@ -57,29 +56,33 @@ public abstract class BaseDQLE2EIT extends SingleE2EIT {
private boolean useXMLAsExpectedDataset;
- private final String adapter;
-
- public BaseDQLE2EIT(final AssertionTestParameter testParam) {
- super(testParam);
- adapter = testParam.getAdapter();
- }
-
- @Before
- public final void init() throws Exception {
- fillDataOnlyOnce();
- expectedDataSource = null == getAssertion().getExpectedDataSourceName() || 1 == getContainerComposer().getExpectedDataSourceMap().size()
- ? getContainerComposer().getExpectedDataSourceMap().values().iterator().next()
- : getContainerComposer().getExpectedDataSourceMap().get(getAssertion().getExpectedDataSourceName());
- useXMLAsExpectedDataset = null != getAssertion().getExpectedDataFile();
- }
-
- private void fillDataOnlyOnce() throws SQLException, ParseException, IOException, JAXBException {
- if (!FILLED_SUITES.contains(getTestParam().getKey())) {
+ /**
+ * Init.
+ *
+ * @param testParam test parameter
+ * @param containerComposer container composer
+ * @throws SQLException SQL exception
+ * @throws ParseException parse exception
+ * @throws IOException IO exception
+ * @throws JAXBException JAXB exception
+ */
+ public final void init(final AssertionTestParameter testParam, final SingleE2EITContainerComposer containerComposer) throws SQLException, ParseException, IOException, JAXBException {
+ fillDataOnlyOnce(testParam, containerComposer);
+ expectedDataSource = null == containerComposer.getAssertion().getExpectedDataSourceName() || 1 == containerComposer.getContainerComposer().getExpectedDataSourceMap().size()
+ ? containerComposer.getContainerComposer().getExpectedDataSourceMap().values().iterator().next()
+ : containerComposer.getContainerComposer().getExpectedDataSourceMap().get(containerComposer.getAssertion().getExpectedDataSourceName());
+ useXMLAsExpectedDataset = null != containerComposer.getAssertion().getExpectedDataFile();
+ }
+
+ private void fillDataOnlyOnce(final AssertionTestParameter testParam, final SingleE2EITContainerComposer containerComposer) throws SQLException, ParseException, IOException, JAXBException {
+ if (!FILLED_SUITES.contains(testParam.getKey())) {
synchronized (FILLED_SUITES) {
- if (!FILLED_SUITES.contains(getTestParam().getKey())) {
- new DataSetEnvironmentManager(new ScenarioDataPath(getTestParam().getScenario()).getDataSetFile(Type.ACTUAL), getContainerComposer().getActualDataSourceMap()).fillData();
- new DataSetEnvironmentManager(new ScenarioDataPath(getTestParam().getScenario()).getDataSetFile(Type.EXPECTED), getContainerComposer().getExpectedDataSourceMap()).fillData();
- FILLED_SUITES.add(getTestParam().getKey());
+ if (!FILLED_SUITES.contains(testParam.getKey())) {
+ new DataSetEnvironmentManager(
+ new ScenarioDataPath(testParam.getScenario()).getDataSetFile(Type.ACTUAL), containerComposer.getContainerComposer().getActualDataSourceMap()).fillData();
+ new DataSetEnvironmentManager(
+ new ScenarioDataPath(testParam.getScenario()).getDataSetFile(Type.EXPECTED), containerComposer.getContainerComposer().getExpectedDataSourceMap()).fillData();
+ FILLED_SUITES.add(testParam.getKey());
}
}
}
@@ -90,22 +93,22 @@ public abstract class BaseDQLE2EIT extends SingleE2EIT {
assertRows(actualResultSet, expectedResultSet);
}
- protected final void assertResultSet(final ResultSet resultSet) throws SQLException {
- assertMetaData(resultSet.getMetaData(), getExpectedColumns());
- assertRows(resultSet, getNotAssertionColumns(), getDataSet().getRows());
+ protected final void assertResultSet(final SingleE2EITContainerComposer containerComposer, final ResultSet resultSet) throws SQLException {
+ assertMetaData(resultSet.getMetaData(), getExpectedColumns(containerComposer));
+ assertRows(resultSet, getNotAssertionColumns(containerComposer), containerComposer.getDataSet().getRows());
}
- private Collection<DataSetColumn> getExpectedColumns() {
+ private Collection<DataSetColumn> getExpectedColumns(final SingleE2EITContainerComposer containerComposer) {
Collection<DataSetColumn> result = new LinkedList<>();
- for (DataSetMetaData each : getDataSet().getMetaDataList()) {
+ for (DataSetMetaData each : containerComposer.getDataSet().getMetaDataList()) {
result.addAll(each.getColumns());
}
return result;
}
- private Collection<String> getNotAssertionColumns() {
+ private Collection<String> getNotAssertionColumns(final SingleE2EITContainerComposer containerComposer) {
Collection<String> result = new LinkedList<>();
- for (DataSetMetaData each : getDataSet().getMetaDataList()) {
+ for (DataSetMetaData each : containerComposer.getDataSet().getMetaDataList()) {
result.addAll(each.getColumns().stream().filter(column -> "false".equals(column.getAssertion())).map(DataSetColumn::getName).collect(Collectors.toList()));
}
return result;
diff --git a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dql/GeneralDQLE2EIT.java b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dql/GeneralDQLE2EIT.java
index fe06807a0a9..35e1a9670d0 100644
--- a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dql/GeneralDQLE2EIT.java
+++ b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/dql/GeneralDQLE2EIT.java
@@ -20,84 +20,90 @@ package org.apache.shardingsphere.test.e2e.engine.dql;
import org.apache.shardingsphere.test.e2e.cases.SQLCommandType;
import org.apache.shardingsphere.test.e2e.cases.SQLExecuteType;
import org.apache.shardingsphere.test.e2e.cases.value.SQLValue;
+import org.apache.shardingsphere.test.e2e.engine.SingleE2EITContainerComposer;
+import org.apache.shardingsphere.test.e2e.framework.E2EITExtension;
import org.apache.shardingsphere.test.e2e.framework.param.array.E2ETestParameterFactory;
import org.apache.shardingsphere.test.e2e.framework.param.model.AssertionTestParameter;
-import org.apache.shardingsphere.test.e2e.framework.runner.ParallelRunningStrategy;
-import org.apache.shardingsphere.test.e2e.framework.runner.ParallelRunningStrategy.ParallelLevel;
-import org.junit.Test;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.api.condition.EnabledIf;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.ArgumentsSource;
+import javax.xml.bind.JAXBException;
+import java.io.IOException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.ParseException;
-import java.util.Collection;
+import java.util.stream.Stream;
import static org.junit.jupiter.api.Assertions.assertTrue;
-@ParallelRunningStrategy(ParallelLevel.CASE)
+@ExtendWith(E2EITExtension.class)
public final class GeneralDQLE2EIT extends BaseDQLE2EIT {
- public GeneralDQLE2EIT(final AssertionTestParameter testParam) {
- super(testParam);
- }
-
- @Parameters(name = "{0}")
- public static Collection<AssertionTestParameter> getTestParameters() {
- return E2ETestParameterFactory.getAssertionTestParameters(SQLCommandType.DQL);
- }
-
- @Test
- public void assertExecuteQuery() throws SQLException, ParseException {
- if (isUseXMLAsExpectedDataset()) {
- assertExecuteQueryWithXmlExpected();
- } else {
- assertExecuteQueryWithExpectedDataSource();
+ @ParameterizedTest(name = "{0}")
+ @EnabledIf("isEnabled")
+ @ArgumentsSource(TestCaseArgumentsProvider.class)
+ public void assertExecuteQuery(final AssertionTestParameter testParam) throws SQLException, ParseException, IOException, JAXBException {
+ try (SingleE2EITContainerComposer containerComposer = new SingleE2EITContainerComposer(testParam)) {
+ init(testParam, containerComposer);
+ if (isUseXMLAsExpectedDataset()) {
+ assertExecuteQueryWithXmlExpected(testParam, containerComposer);
+ } else {
+ assertExecuteQueryWithExpectedDataSource(containerComposer);
+ }
}
+
}
- private void assertExecuteQueryWithXmlExpected() throws SQLException, ParseException {
+ private void assertExecuteQueryWithXmlExpected(final AssertionTestParameter testParam, final SingleE2EITContainerComposer containerComposer) throws SQLException, ParseException {
// TODO Fix jdbc adapter
- if ("jdbc".equals(getAdapter())) {
+ if ("jdbc".equals(testParam.getAdapter())) {
return;
}
try (
- Connection connection = getContainerComposer().getTargetDataSource().getConnection();
+ Connection connection = containerComposer.getContainerComposer().getTargetDataSource().getConnection();
Statement statement = connection.createStatement();
- ResultSet resultSet = statement.executeQuery(getSQL())) {
- assertResultSet(resultSet);
+ ResultSet resultSet = statement.executeQuery(containerComposer.getSQL())) {
+ assertResultSet(containerComposer, resultSet);
}
}
- private void assertExecuteQueryWithExpectedDataSource() throws SQLException, ParseException {
+ private void assertExecuteQueryWithExpectedDataSource(final SingleE2EITContainerComposer containerComposer) throws SQLException, ParseException {
try (
- Connection actualConnection = getContainerComposer().getTargetDataSource().getConnection();
+ Connection actualConnection = containerComposer.getContainerComposer().getTargetDataSource().getConnection();
Connection expectedConnection = getExpectedDataSource().getConnection()) {
- if (SQLExecuteType.Literal == getSqlExecuteType()) {
- assertExecuteQueryForStatement(actualConnection, expectedConnection);
+ if (SQLExecuteType.Literal == containerComposer.getSqlExecuteType()) {
+ assertExecuteQueryForStatement(containerComposer, actualConnection, expectedConnection);
} else {
- assertExecuteQueryForPreparedStatement(actualConnection, expectedConnection);
+ assertExecuteQueryForPreparedStatement(containerComposer, actualConnection, expectedConnection);
}
}
}
- private void assertExecuteQueryForStatement(final Connection actualConnection, final Connection expectedConnection) throws SQLException, ParseException {
+ private void assertExecuteQueryForStatement(final SingleE2EITContainerComposer containerComposer,
+ final Connection actualConnection, final Connection expectedConnection) throws SQLException, ParseException {
try (
Statement actualStatement = actualConnection.createStatement();
- ResultSet actualResultSet = actualStatement.executeQuery(getSQL());
+ ResultSet actualResultSet = actualStatement.executeQuery(containerComposer.getSQL());
Statement expectedStatement = expectedConnection.createStatement();
- ResultSet expectedResultSet = expectedStatement.executeQuery(getSQL())) {
+ ResultSet expectedResultSet = expectedStatement.executeQuery(containerComposer.getSQL())) {
assertResultSet(actualResultSet, expectedResultSet);
}
}
- private void assertExecuteQueryForPreparedStatement(final Connection actualConnection, final Connection expectedConnection) throws SQLException, ParseException {
+ private void assertExecuteQueryForPreparedStatement(final SingleE2EITContainerComposer containerComposer,
+ final Connection actualConnection, final Connection expectedConnection) throws SQLException, ParseException {
try (
- PreparedStatement actualPreparedStatement = actualConnection.prepareStatement(getSQL());
- PreparedStatement expectedPreparedStatement = expectedConnection.prepareStatement(getSQL())) {
- for (SQLValue each : getAssertion().getSQLValues()) {
+ PreparedStatement actualPreparedStatement = actualConnection.prepareStatement(containerComposer.getSQL());
+ PreparedStatement expectedPreparedStatement = expectedConnection.prepareStatement(containerComposer.getSQL())) {
+ for (SQLValue each : containerComposer.getAssertion().getSQLValues()) {
actualPreparedStatement.setObject(each.getIndex(), each.getValue());
expectedPreparedStatement.setObject(each.getIndex(), each.getValue());
}
@@ -109,46 +115,52 @@ public final class GeneralDQLE2EIT extends BaseDQLE2EIT {
}
}
- @Test
- public void assertExecute() throws SQLException, ParseException {
- if (isUseXMLAsExpectedDataset()) {
- assertExecuteWithXmlExpected();
- } else {
- assertExecuteWithExpectedDataSource();
+ @ParameterizedTest(name = "{0}")
+ @EnabledIf("isEnabled")
+ @ArgumentsSource(TestCaseArgumentsProvider.class)
+ public void assertExecute(final AssertionTestParameter testParam) throws SQLException, ParseException, JAXBException, IOException {
+ try (SingleE2EITContainerComposer containerComposer = new SingleE2EITContainerComposer(testParam)) {
+ init(testParam, containerComposer);
+ if (isUseXMLAsExpectedDataset()) {
+ assertExecuteWithXmlExpected(testParam, containerComposer);
+ } else {
+ assertExecuteWithExpectedDataSource(containerComposer);
+ }
}
}
- private void assertExecuteWithXmlExpected() throws SQLException, ParseException {
+ private void assertExecuteWithXmlExpected(final AssertionTestParameter testParam, final SingleE2EITContainerComposer containerComposer) throws SQLException, ParseException {
// TODO Fix jdbc adapter
- if ("jdbc".equals(getAdapter())) {
+ if ("jdbc".equals(testParam.getAdapter())) {
return;
}
try (
- Connection connection = getContainerComposer().getTargetDataSource().getConnection();
+ Connection connection = containerComposer.getContainerComposer().getTargetDataSource().getConnection();
Statement statement = connection.createStatement()) {
- assertTrue(statement.execute(getSQL()), "Not a query statement.");
+ assertTrue(statement.execute(containerComposer.getSQL()), "Not a query statement.");
ResultSet resultSet = statement.getResultSet();
- assertResultSet(resultSet);
+ assertResultSet(containerComposer, resultSet);
}
}
- private void assertExecuteWithExpectedDataSource() throws SQLException, ParseException {
+ private void assertExecuteWithExpectedDataSource(final SingleE2EITContainerComposer containerComposer) throws SQLException, ParseException {
try (
- Connection actualConnection = getContainerComposer().getTargetDataSource().getConnection();
+ Connection actualConnection = containerComposer.getContainerComposer().getTargetDataSource().getConnection();
Connection expectedConnection = getExpectedDataSource().getConnection()) {
- if (SQLExecuteType.Literal == getSqlExecuteType()) {
- assertExecuteForStatement(actualConnection, expectedConnection);
+ if (SQLExecuteType.Literal == containerComposer.getSqlExecuteType()) {
+ assertExecuteForStatement(containerComposer, actualConnection, expectedConnection);
} else {
- assertExecuteForPreparedStatement(actualConnection, expectedConnection);
+ assertExecuteForPreparedStatement(containerComposer, actualConnection, expectedConnection);
}
}
}
- private void assertExecuteForStatement(final Connection actualConnection, final Connection expectedConnection) throws SQLException, ParseException {
+ private void assertExecuteForStatement(final SingleE2EITContainerComposer containerComposer,
+ final Connection actualConnection, final Connection expectedConnection) throws SQLException, ParseException {
try (
Statement actualStatement = actualConnection.createStatement();
Statement expectedStatement = expectedConnection.createStatement()) {
- assertTrue(actualStatement.execute(getSQL()) && expectedStatement.execute(getSQL()), "Not a query statement.");
+ assertTrue(actualStatement.execute(containerComposer.getSQL()) && expectedStatement.execute(containerComposer.getSQL()), "Not a query statement.");
try (
ResultSet actualResultSet = actualStatement.getResultSet();
ResultSet expectedResultSet = expectedStatement.getResultSet()) {
@@ -157,11 +169,12 @@ public final class GeneralDQLE2EIT extends BaseDQLE2EIT {
}
}
- private void assertExecuteForPreparedStatement(final Connection actualConnection, final Connection expectedConnection) throws SQLException, ParseException {
+ private void assertExecuteForPreparedStatement(final SingleE2EITContainerComposer containerComposer,
+ final Connection actualConnection, final Connection expectedConnection) throws SQLException, ParseException {
try (
- PreparedStatement actualPreparedStatement = actualConnection.prepareStatement(getSQL());
- PreparedStatement expectedPreparedStatement = expectedConnection.prepareStatement(getSQL())) {
- for (SQLValue each : getAssertion().getSQLValues()) {
+ PreparedStatement actualPreparedStatement = actualConnection.prepareStatement(containerComposer.getSQL());
+ PreparedStatement expectedPreparedStatement = expectedConnection.prepareStatement(containerComposer.getSQL())) {
+ for (SQLValue each : containerComposer.getAssertion().getSQLValues()) {
actualPreparedStatement.setObject(each.getIndex(), each.getValue());
expectedPreparedStatement.setObject(each.getIndex(), each.getValue());
}
@@ -173,4 +186,16 @@ public final class GeneralDQLE2EIT extends BaseDQLE2EIT {
}
}
}
+
+ private static boolean isEnabled() {
+ return E2ETestParameterFactory.containsTestParameter();
+ }
+
+ private static class TestCaseArgumentsProvider implements ArgumentsProvider {
+
+ @Override
+ public Stream<? extends Arguments> provideArguments(final ExtensionContext extensionContext) {
+ return E2ETestParameterFactory.getAssertionTestParameters(SQLCommandType.DQL).stream().map(Arguments::of);
+ }
+ }
}
diff --git a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/ral/BaseRALE2EIT.java b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/ral/BaseRALE2EIT.java
index e5f259d6866..03eaf124fcd 100644
--- a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/ral/BaseRALE2EIT.java
+++ b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/ral/BaseRALE2EIT.java
@@ -21,10 +21,7 @@ import com.google.common.base.Splitter;
import org.apache.shardingsphere.test.e2e.cases.dataset.metadata.DataSetColumn;
import org.apache.shardingsphere.test.e2e.cases.dataset.metadata.DataSetMetaData;
import org.apache.shardingsphere.test.e2e.cases.dataset.row.DataSetRow;
-import org.apache.shardingsphere.test.e2e.engine.SingleE2EIT;
-import org.apache.shardingsphere.test.e2e.framework.param.model.AssertionTestParameter;
-import org.junit.After;
-import org.junit.Before;
+import org.apache.shardingsphere.test.e2e.engine.SingleE2EITContainerComposer;
import java.sql.Connection;
import java.sql.PreparedStatement;
@@ -41,35 +38,41 @@ import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertTrue;
-public abstract class BaseRALE2EIT extends SingleE2EIT {
+public abstract class BaseRALE2EIT {
- public BaseRALE2EIT(final AssertionTestParameter testParam) {
- super(testParam);
- }
-
- @Before
- public final void init() throws Exception {
- if (null != getAssertion().getInitialSQL()) {
- try (Connection connection = getContainerComposer().getTargetDataSource().getConnection()) {
- executeInitSQLs(connection);
+ /**
+ * Init.
+ *
+ * @param containerComposer container composer
+ * @throws SQLException SQL exception
+ */
+ public final void init(final SingleE2EITContainerComposer containerComposer) throws SQLException {
+ if (null != containerComposer.getAssertion().getInitialSQL()) {
+ try (Connection connection = containerComposer.getContainerComposer().getTargetDataSource().getConnection()) {
+ executeInitSQLs(containerComposer, connection);
}
}
}
- @After
- public final void tearDown() throws Exception {
- if (null != getAssertion().getDestroySQL()) {
- try (Connection connection = getContainerComposer().getTargetDataSource().getConnection()) {
- executeDestroySQLs(connection);
+ /**
+ * Tear down.
+ *
+ * @param containerComposer container composer
+ * @throws SQLException SQL exception
+ */
+ public final void tearDown(final SingleE2EITContainerComposer containerComposer) throws SQLException {
+ if (null != containerComposer.getAssertion().getDestroySQL()) {
+ try (Connection connection = containerComposer.getContainerComposer().getTargetDataSource().getConnection()) {
+ executeDestroySQLs(containerComposer, connection);
}
}
}
- private void executeInitSQLs(final Connection connection) throws SQLException {
- if (null == getAssertion().getInitialSQL().getSql()) {
+ private void executeInitSQLs(final SingleE2EITContainerComposer containerComposer, final Connection connection) throws SQLException {
+ if (null == containerComposer.getAssertion().getInitialSQL().getSql()) {
return;
}
- for (String each : Splitter.on(";").trimResults().splitToList(getAssertion().getInitialSQL().getSql())) {
+ for (String each : Splitter.on(";").trimResults().splitToList(containerComposer.getAssertion().getInitialSQL().getSql())) {
try (PreparedStatement preparedStatement = connection.prepareStatement(each)) {
preparedStatement.executeUpdate();
}
@@ -77,16 +80,16 @@ public abstract class BaseRALE2EIT extends SingleE2EIT {
sleep(1000);
}
- private void executeDestroySQLs(final Connection connection) throws SQLException {
- if (null == getAssertion().getDestroySQL().getSql()) {
+ private void executeDestroySQLs(final SingleE2EITContainerComposer containerComposer, final Connection connection) throws SQLException {
+ if (null == containerComposer.getAssertion().getDestroySQL().getSql()) {
return;
}
- for (String each : Splitter.on(";").trimResults().splitToList(getAssertion().getDestroySQL().getSql())) {
+ for (String each : Splitter.on(";").trimResults().splitToList(containerComposer.getAssertion().getDestroySQL().getSql())) {
try (PreparedStatement preparedStatement = connection.prepareStatement(each)) {
preparedStatement.executeUpdate();
}
}
- sleep(1000);
+ sleep(1000L);
}
protected void sleep(final long timeout) {
@@ -96,22 +99,22 @@ public abstract class BaseRALE2EIT extends SingleE2EIT {
}
}
- protected final void assertResultSet(final ResultSet resultSet) throws SQLException {
- assertMetaData(resultSet.getMetaData(), getExpectedColumns());
- assertRows(resultSet, getNotAssertionColumns(), getDataSet().getRows());
+ protected final void assertResultSet(final SingleE2EITContainerComposer containerComposer, final ResultSet resultSet) throws SQLException {
+ assertMetaData(resultSet.getMetaData(), getExpectedColumns(containerComposer));
+ assertRows(resultSet, getNotAssertionColumns(containerComposer), containerComposer.getDataSet().getRows());
}
- private Collection<DataSetColumn> getExpectedColumns() {
+ private Collection<DataSetColumn> getExpectedColumns(final SingleE2EITContainerComposer containerComposer) {
Collection<DataSetColumn> result = new LinkedList<>();
- for (DataSetMetaData each : getDataSet().getMetaDataList()) {
+ for (DataSetMetaData each : containerComposer.getDataSet().getMetaDataList()) {
result.addAll(each.getColumns());
}
return result;
}
- private Collection<String> getNotAssertionColumns() {
+ private Collection<String> getNotAssertionColumns(final SingleE2EITContainerComposer containerComposer) {
Collection<String> result = new LinkedList<>();
- for (DataSetMetaData each : getDataSet().getMetaDataList()) {
+ for (DataSetMetaData each : containerComposer.getDataSet().getMetaDataList()) {
result.addAll(each.getColumns().stream().filter(column -> "false".equals(column.getAssertion())).map(DataSetColumn::getName).collect(Collectors.toList()));
}
return result;
diff --git a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/ral/GeneralRALE2EIT.java b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/ral/GeneralRALE2EIT.java
index 737ef4e5b5d..e8a309ee319 100644
--- a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/ral/GeneralRALE2EIT.java
+++ b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/ral/GeneralRALE2EIT.java
@@ -18,55 +18,72 @@
package org.apache.shardingsphere.test.e2e.engine.ral;
import org.apache.shardingsphere.test.e2e.cases.SQLCommandType;
+import org.apache.shardingsphere.test.e2e.engine.SingleE2EITContainerComposer;
+import org.apache.shardingsphere.test.e2e.framework.E2EITExtension;
import org.apache.shardingsphere.test.e2e.framework.param.array.E2ETestParameterFactory;
import org.apache.shardingsphere.test.e2e.framework.param.model.AssertionTestParameter;
-import org.apache.shardingsphere.test.e2e.framework.runner.ParallelRunningStrategy;
-import org.apache.shardingsphere.test.e2e.framework.runner.ParallelRunningStrategy.ParallelLevel;
-import org.junit.Test;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.api.condition.EnabledIf;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.ArgumentsSource;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.ParseException;
-import java.util.Collection;
+import java.util.stream.Stream;
-@ParallelRunningStrategy(ParallelLevel.SCENARIO)
+@ExtendWith(E2EITExtension.class)
public final class GeneralRALE2EIT extends BaseRALE2EIT {
- public GeneralRALE2EIT(final AssertionTestParameter testParam) {
- super(testParam);
- }
-
- @Parameters(name = "{0}")
- public static Collection<AssertionTestParameter> getTestParameters() {
- return E2ETestParameterFactory.getAssertionTestParameters(SQLCommandType.RAL);
+ @ParameterizedTest(name = "{0}")
+ @EnabledIf("isEnabled")
+ @ArgumentsSource(TestCaseArgumentsProvider.class)
+ public void assertExecute(final AssertionTestParameter testParam) throws SQLException, ParseException {
+ try (SingleE2EITContainerComposer containerComposer = new SingleE2EITContainerComposer(testParam)) {
+ init(containerComposer);
+ assertExecute(containerComposer);
+ tearDown(containerComposer);
+ }
}
- @Test
- public void assertExecute() throws SQLException, ParseException {
- try (Connection connection = getContainerComposer().getTargetDataSource().getConnection()) {
- try (
- Statement statement = connection.createStatement()) {
- assertResultSet(statement);
+ private void assertExecute(final SingleE2EITContainerComposer containerComposer) throws SQLException, ParseException {
+ try (Connection connection = containerComposer.getContainerComposer().getTargetDataSource().getConnection()) {
+ try (Statement statement = connection.createStatement()) {
+ assertResultSet(containerComposer, statement);
}
}
}
- private void assertResultSet(final Statement statement) throws SQLException, ParseException {
- if (null == getAssertion().getAssertionSQL()) {
- assertResultSet(statement, getSQL());
+ private void assertResultSet(final SingleE2EITContainerComposer containerComposer, final Statement statement) throws SQLException, ParseException {
+ if (null == containerComposer.getAssertion().getAssertionSQL()) {
+ assertResultSet(containerComposer, statement, containerComposer.getSQL());
} else {
- statement.execute(getSQL());
+ statement.execute(containerComposer.getSQL());
sleep(2000);
- assertResultSet(statement, getAssertion().getAssertionSQL().getSql());
+ assertResultSet(containerComposer, statement, containerComposer.getAssertion().getAssertionSQL().getSql());
}
}
- private void assertResultSet(final Statement statement, final String sql) throws SQLException {
+ private void assertResultSet(final SingleE2EITContainerComposer containerComposer, final Statement statement, final String sql) throws SQLException {
try (ResultSet resultSet = statement.executeQuery(sql)) {
- assertResultSet(resultSet);
+ assertResultSet(containerComposer, resultSet);
+ }
+ }
+
+ private static boolean isEnabled() {
+ return E2ETestParameterFactory.containsTestParameter();
+ }
+
+ private static class TestCaseArgumentsProvider implements ArgumentsProvider {
+
+ @Override
+ public Stream<? extends Arguments> provideArguments(final ExtensionContext extensionContext) {
+ return E2ETestParameterFactory.getAssertionTestParameters(SQLCommandType.RAL).stream().map(Arguments::of);
}
}
}
diff --git a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/rdl/BaseRDLE2EIT.java b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/rdl/BaseRDLE2EIT.java
index 14e439f35c5..87d2dba21f0 100644
--- a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/rdl/BaseRDLE2EIT.java
+++ b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/rdl/BaseRDLE2EIT.java
@@ -21,10 +21,7 @@ import com.google.common.base.Splitter;
import org.apache.shardingsphere.test.e2e.cases.dataset.metadata.DataSetColumn;
import org.apache.shardingsphere.test.e2e.cases.dataset.metadata.DataSetMetaData;
import org.apache.shardingsphere.test.e2e.cases.dataset.row.DataSetRow;
-import org.apache.shardingsphere.test.e2e.engine.SingleE2EIT;
-import org.apache.shardingsphere.test.e2e.framework.param.model.AssertionTestParameter;
-import org.junit.After;
-import org.junit.Before;
+import org.apache.shardingsphere.test.e2e.engine.SingleE2EITContainerComposer;
import java.sql.Connection;
import java.sql.PreparedStatement;
@@ -40,34 +37,40 @@ import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertTrue;
-public abstract class BaseRDLE2EIT extends SingleE2EIT {
+public abstract class BaseRDLE2EIT {
- public BaseRDLE2EIT(final AssertionTestParameter testParam) {
- super(testParam);
- }
-
- @Before
- public final void init() throws Exception {
- try (Connection connection = getContainerComposer().getTargetDataSource().getConnection()) {
- executeInitSQLs(connection);
+ /**
+ * Init.
+ *
+ * @param containerComposer container composer
+ * @throws SQLException SQL exception
+ */
+ public final void init(final SingleE2EITContainerComposer containerComposer) throws SQLException {
+ try (Connection connection = containerComposer.getContainerComposer().getTargetDataSource().getConnection()) {
+ executeInitSQLs(containerComposer, connection);
}
}
- @After
- public final void tearDown() throws Exception {
- if (null != getAssertion().getDestroySQL()) {
- try (Connection connection = getContainerComposer().getTargetDataSource().getConnection()) {
- executeDestroySQLs(connection);
+ /**
+ * Tear down.
+ *
+ * @param containerComposer container composer
+ * @throws SQLException SQL exception
+ */
+ public final void tearDown(final SingleE2EITContainerComposer containerComposer) throws SQLException {
+ if (null != containerComposer.getAssertion().getDestroySQL()) {
+ try (Connection connection = containerComposer.getContainerComposer().getTargetDataSource().getConnection()) {
+ executeDestroySQLs(containerComposer, connection);
}
}
sleep();
}
- private void executeInitSQLs(final Connection connection) throws SQLException {
- if (null == getAssertion().getInitialSQL() || null == getAssertion().getInitialSQL().getSql()) {
+ private void executeInitSQLs(final SingleE2EITContainerComposer containerComposer, final Connection connection) throws SQLException {
+ if (null == containerComposer.getAssertion().getInitialSQL() || null == containerComposer.getAssertion().getInitialSQL().getSql()) {
return;
}
- for (String each : Splitter.on(";").trimResults().splitToList(getAssertion().getInitialSQL().getSql())) {
+ for (String each : Splitter.on(";").trimResults().splitToList(containerComposer.getAssertion().getInitialSQL().getSql())) {
try (PreparedStatement preparedStatement = connection.prepareStatement(each)) {
preparedStatement.executeUpdate();
sleep();
@@ -75,11 +78,11 @@ public abstract class BaseRDLE2EIT extends SingleE2EIT {
}
}
- private void executeDestroySQLs(final Connection connection) throws SQLException {
- if (null == getAssertion().getDestroySQL().getSql()) {
+ private void executeDestroySQLs(final SingleE2EITContainerComposer containerComposer, final Connection connection) throws SQLException {
+ if (null == containerComposer.getAssertion().getDestroySQL().getSql()) {
return;
}
- for (String each : Splitter.on(";").trimResults().splitToList(getAssertion().getDestroySQL().getSql())) {
+ for (String each : Splitter.on(";").trimResults().splitToList(containerComposer.getAssertion().getDestroySQL().getSql())) {
try (PreparedStatement preparedStatement = connection.prepareStatement(each)) {
preparedStatement.executeUpdate();
sleep();
@@ -89,19 +92,19 @@ public abstract class BaseRDLE2EIT extends SingleE2EIT {
protected void sleep() {
try {
- TimeUnit.SECONDS.sleep(2);
+ TimeUnit.SECONDS.sleep(2L);
} catch (final InterruptedException ignored) {
}
}
- protected final void assertResultSet(final ResultSet resultSet) throws SQLException {
- assertMetaData(resultSet.getMetaData(), getExpectedColumns());
- assertRows(resultSet, getDataSet().getRows());
+ protected final void assertResultSet(final SingleE2EITContainerComposer containerComposer, final ResultSet resultSet) throws SQLException {
+ assertMetaData(resultSet.getMetaData(), getExpectedColumns(containerComposer));
+ assertRows(resultSet, containerComposer.getDataSet().getRows());
}
- private Collection<DataSetColumn> getExpectedColumns() {
+ private Collection<DataSetColumn> getExpectedColumns(final SingleE2EITContainerComposer containerComposer) {
Collection<DataSetColumn> result = new LinkedList<>();
- for (DataSetMetaData each : getDataSet().getMetaDataList()) {
+ for (DataSetMetaData each : containerComposer.getDataSet().getMetaDataList()) {
result.addAll(each.getColumns());
}
return result;
diff --git a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/rdl/GeneralRDLE2EIT.java b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/rdl/GeneralRDLE2EIT.java
index a51b1fdaec1..cb612513393 100644
--- a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/rdl/GeneralRDLE2EIT.java
+++ b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/rdl/GeneralRDLE2EIT.java
@@ -18,53 +18,71 @@
package org.apache.shardingsphere.test.e2e.engine.rdl;
import org.apache.shardingsphere.test.e2e.cases.SQLCommandType;
+import org.apache.shardingsphere.test.e2e.engine.SingleE2EITContainerComposer;
+import org.apache.shardingsphere.test.e2e.framework.E2EITExtension;
import org.apache.shardingsphere.test.e2e.framework.param.array.E2ETestParameterFactory;
import org.apache.shardingsphere.test.e2e.framework.param.model.AssertionTestParameter;
-import org.apache.shardingsphere.test.e2e.framework.runner.ParallelRunningStrategy;
-import org.apache.shardingsphere.test.e2e.framework.runner.ParallelRunningStrategy.ParallelLevel;
-import org.junit.Test;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.api.condition.EnabledIf;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.ArgumentsSource;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.ParseException;
-import java.util.Collection;
+import java.util.stream.Stream;
import static org.junit.jupiter.api.Assertions.assertNotNull;
-@ParallelRunningStrategy(ParallelLevel.SCENARIO)
+@ExtendWith(E2EITExtension.class)
public final class GeneralRDLE2EIT extends BaseRDLE2EIT {
- public GeneralRDLE2EIT(final AssertionTestParameter testParam) {
- super(testParam);
- }
-
- @Parameters(name = "{0}")
- public static Collection<AssertionTestParameter> getTestParameters() {
- return E2ETestParameterFactory.getAssertionTestParameters(SQLCommandType.RDL);
+ @ParameterizedTest(name = "{0}")
+ @EnabledIf("isEnabled")
+ @ArgumentsSource(TestCaseArgumentsProvider.class)
+ public void assertExecute(final AssertionTestParameter testParam) throws SQLException, ParseException {
+ try (SingleE2EITContainerComposer containerComposer = new SingleE2EITContainerComposer(testParam)) {
+ init(containerComposer);
+ assertExecute(testParam, containerComposer);
+ tearDown(containerComposer);
+ }
}
- @Test
- public void assertExecute() throws SQLException, ParseException {
- assertNotNull(getAssertion().getAssertionSQL(), "Assertion SQL is required");
- try (Connection connection = getContainerComposer().getTargetDataSource().getConnection()) {
+ private void assertExecute(final AssertionTestParameter testParam, final SingleE2EITContainerComposer containerComposer) throws SQLException, ParseException {
+ assertNotNull(testParam.getAssertion().getAssertionSQL(), "Assertion SQL is required");
+ try (Connection connection = containerComposer.getContainerComposer().getTargetDataSource().getConnection()) {
try (Statement statement = connection.createStatement()) {
- executeSQLCase(statement);
+ executeSQLCase(containerComposer, statement);
sleep();
- assertResultSet(statement);
+ assertResultSet(containerComposer, statement);
}
}
}
- private void executeSQLCase(final Statement statement) throws SQLException, ParseException {
- statement.execute(getSQL());
+ private void executeSQLCase(final SingleE2EITContainerComposer containerComposer, final Statement statement) throws SQLException, ParseException {
+ statement.execute(containerComposer.getSQL());
+ }
+
+ private void assertResultSet(final SingleE2EITContainerComposer containerComposer, final Statement statement) throws SQLException {
+ try (ResultSet resultSet = statement.executeQuery(containerComposer.getAssertion().getAssertionSQL().getSql())) {
+ assertResultSet(containerComposer, resultSet);
+ }
+ }
+
+ private static boolean isEnabled() {
+ return E2ETestParameterFactory.containsTestParameter();
}
- private void assertResultSet(final Statement statement) throws SQLException {
- try (ResultSet resultSet = statement.executeQuery(getAssertion().getAssertionSQL().getSql())) {
- assertResultSet(resultSet);
+ private static class TestCaseArgumentsProvider implements ArgumentsProvider {
+
+ @Override
+ public Stream<? extends Arguments> provideArguments(final ExtensionContext extensionContext) {
+ return E2ETestParameterFactory.getAssertionTestParameters(SQLCommandType.RDL).stream().map(Arguments::of);
}
}
}
diff --git a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/rql/BaseRQLE2EIT.java b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/rql/BaseRQLE2EIT.java
index 42dfab23eed..317d4b93dec 100644
--- a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/rql/BaseRQLE2EIT.java
+++ b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/rql/BaseRQLE2EIT.java
@@ -20,8 +20,7 @@ package org.apache.shardingsphere.test.e2e.engine.rql;
import org.apache.shardingsphere.test.e2e.cases.dataset.metadata.DataSetColumn;
import org.apache.shardingsphere.test.e2e.cases.dataset.metadata.DataSetMetaData;
import org.apache.shardingsphere.test.e2e.cases.dataset.row.DataSetRow;
-import org.apache.shardingsphere.test.e2e.engine.SingleE2EIT;
-import org.apache.shardingsphere.test.e2e.framework.param.model.AssertionTestParameter;
+import org.apache.shardingsphere.test.e2e.engine.SingleE2EITContainerComposer;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
@@ -34,20 +33,16 @@ import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertTrue;
-public abstract class BaseRQLE2EIT extends SingleE2EIT {
+public abstract class BaseRQLE2EIT {
- public BaseRQLE2EIT(final AssertionTestParameter testParam) {
- super(testParam);
+ protected final void assertResultSet(final SingleE2EITContainerComposer containerComposer, final ResultSet resultSet) throws SQLException {
+ assertMetaData(resultSet.getMetaData(), getExpectedColumns(containerComposer));
+ assertRows(resultSet, containerComposer.getDataSet().getRows());
}
- protected final void assertResultSet(final ResultSet resultSet) throws SQLException {
- assertMetaData(resultSet.getMetaData(), getExpectedColumns());
- assertRows(resultSet, getDataSet().getRows());
- }
-
- private Collection<DataSetColumn> getExpectedColumns() {
+ private Collection<DataSetColumn> getExpectedColumns(final SingleE2EITContainerComposer containerComposer) {
Collection<DataSetColumn> result = new LinkedList<>();
- for (DataSetMetaData each : getDataSet().getMetaDataList()) {
+ for (DataSetMetaData each : containerComposer.getDataSet().getMetaDataList()) {
result.addAll(each.getColumns());
}
return result;
diff --git a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/rql/GeneralRQLE2EIT.java b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/rql/GeneralRQLE2EIT.java
index 3190e093cd3..cbdc2731443 100644
--- a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/rql/GeneralRQLE2EIT.java
+++ b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/engine/rql/GeneralRQLE2EIT.java
@@ -18,40 +18,56 @@
package org.apache.shardingsphere.test.e2e.engine.rql;
import org.apache.shardingsphere.test.e2e.cases.SQLCommandType;
+import org.apache.shardingsphere.test.e2e.engine.SingleE2EITContainerComposer;
+import org.apache.shardingsphere.test.e2e.framework.E2EITExtension;
import org.apache.shardingsphere.test.e2e.framework.param.array.E2ETestParameterFactory;
import org.apache.shardingsphere.test.e2e.framework.param.model.AssertionTestParameter;
-import org.apache.shardingsphere.test.e2e.framework.runner.ParallelRunningStrategy;
-import org.apache.shardingsphere.test.e2e.framework.runner.ParallelRunningStrategy.ParallelLevel;
-import org.junit.Test;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.api.condition.EnabledIf;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.ArgumentsSource;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.ParseException;
-import java.util.Collection;
+import java.util.stream.Stream;
-@ParallelRunningStrategy(ParallelLevel.CASE)
+@ExtendWith(E2EITExtension.class)
public final class GeneralRQLE2EIT extends BaseRQLE2EIT {
- public GeneralRQLE2EIT(final AssertionTestParameter testParam) {
- super(testParam);
- }
-
- @Parameters(name = "{0}")
- public static Collection<AssertionTestParameter> getTestParameters() {
- return E2ETestParameterFactory.getAssertionTestParameters(SQLCommandType.RQL);
+ @ParameterizedTest(name = "{0}")
+ @EnabledIf("isEnabled")
+ @ArgumentsSource(TestCaseArgumentsProvider.class)
+ public void assertExecute(final AssertionTestParameter testParam) throws SQLException, ParseException {
+ try (SingleE2EITContainerComposer containerComposer = new SingleE2EITContainerComposer(testParam)) {
+ assertExecute(containerComposer);
+ }
}
- @Test
- public void assertExecute() throws SQLException, ParseException {
- try (Connection connection = getContainerComposer().getTargetDataSource().getConnection()) {
+ private void assertExecute(final SingleE2EITContainerComposer containerComposer) throws SQLException, ParseException {
+ try (Connection connection = containerComposer.getContainerComposer().getTargetDataSource().getConnection()) {
try (
Statement statement = connection.createStatement();
- ResultSet resultSet = statement.executeQuery(getSQL())) {
- assertResultSet(resultSet);
+ ResultSet resultSet = statement.executeQuery(containerComposer.getSQL())) {
+ assertResultSet(containerComposer, resultSet);
}
}
}
+
+ private static boolean isEnabled() {
+ return E2ETestParameterFactory.containsTestParameter();
+ }
+
+ private static class TestCaseArgumentsProvider implements ArgumentsProvider {
+
+ @Override
+ public Stream<? extends Arguments> provideArguments(final ExtensionContext extensionContext) {
+ return E2ETestParameterFactory.getAssertionTestParameters(SQLCommandType.RQL).stream().map(Arguments::of);
+ }
+ }
}
diff --git a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/framework/watcher/E2EWatcher.java b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/framework/E2EITExtension.java
similarity index 77%
rename from test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/framework/watcher/E2EWatcher.java
rename to test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/framework/E2EITExtension.java
index 98f4db846c8..8c193d85882 100644
--- a/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/framework/watcher/E2EWatcher.java
+++ b/test/e2e/suite/src/test/java/org/apache/shardingsphere/test/e2e/framework/E2EITExtension.java
@@ -15,25 +15,24 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.test.e2e.framework.watcher;
+package org.apache.shardingsphere.test.e2e.framework;
import lombok.extern.slf4j.Slf4j;
-import org.junit.rules.TestWatcher;
-import org.junit.runner.Description;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.api.extension.TestWatcher;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
/**
- * E2E test watcher.
+ * E2E IT extension.
*/
@Slf4j
-public final class E2EWatcher extends TestWatcher {
+public final class E2EITExtension implements TestWatcher {
@Override
- protected void failed(final Throwable cause, final Description description) {
- log.error("Error case: {}, message: {}", description.getMethodName(), getStackTrace(cause));
- super.failed(cause, description);
+ public void testFailed(final ExtensionContext context, final Throwable cause) {
+ log.error("Error case: {}, message: {}", context.getRequiredTestMethod().getName(), getStackTrace(cause));
}
private String getStackTrace(final Throwable cause) {