From faa4f4742a1b82f27f9a1fd66b414624402f2c61 Mon Sep 17 00:00:00 2001 From: rmpestano Date: Sat, 3 Sep 2016 23:26:58 -0300 Subject: [PATCH] fixes #41 - adds configuration via @DBUnit annotation and global config file dbunit.yml --- README.adoc | 12 +- .../dbunit/rules/cdi/DBUnitInterceptor.java | 32 +- .../dbunit/rules/cdi/DataSetProcessor.java | 14 +- .../com/github/dbunit/rules/DBUnitRule.java | 80 ++-- .../DBUnit.java} | 4 +- .../rules/api/dataset/DataSetExecutor.java | 15 +- .../rules/api/dbunit/DBUnitConfigModel.java | 83 ---- .../rules/configuration/DBUnitConfig.java | 103 +++++ .../DataSetConfig.java} | 390 ++++++++++-------- .../rules/configuration/GlobaConfig.java | 63 +++ .../rules/dataset/DataSetExecutorImpl.java | 113 +++-- core/src/main/resources/default/dbunit.yml | 10 + .../rules/DBUnitClassLevelAnnotationIt.java | 4 +- .../github/dbunit/rules/DBUnitRulesIt.java | 4 +- .../dbunit/rules/DataSetExecutorIt.java | 34 +- .../dbunit/rules/DateReplacementsIt.java | 4 +- .../github/dbunit/rules/EmptyDataSetIt.java | 4 +- .../dbunit/rules/ExpectedDataSetIt.java | 7 +- .../dbunit/rules/MultipleExecutorsIt.java | 34 +- .../com/github/dbunit/rules/ScriptsIt.java | 4 +- .../github/dbunit/rules/TransactionIt.java | 4 +- .../configuration/ConfigurationTest.java | 106 +++++ .../test/resources/config/sample-dbunit.yml | 10 + .../rules/example/UserRepositoryTest.java | 10 +- .../src/test/java/JooqDBUnitTest.java | 5 +- .../withoutcdi/ContactStepsWithoutCDI.java | 4 +- .../github/dbunit/junit5/DBUnitExtension.java | 38 +- pom.xml | 2 +- 28 files changed, 727 insertions(+), 466 deletions(-) rename core/src/main/java/com/github/dbunit/rules/api/{dbunit/DBUnitConfig.java => configuration/DBUnit.java} (95%) delete mode 100644 core/src/main/java/com/github/dbunit/rules/api/dbunit/DBUnitConfigModel.java create mode 100644 core/src/main/java/com/github/dbunit/rules/configuration/DBUnitConfig.java rename core/src/main/java/com/github/dbunit/rules/{api/dataset/DataSetModel.java => configuration/DataSetConfig.java} (66%) create mode 100644 core/src/main/java/com/github/dbunit/rules/configuration/GlobaConfig.java create mode 100644 core/src/main/resources/default/dbunit.yml create mode 100644 core/src/test/java/com/github/dbunit/rules/configuration/ConfigurationTest.java create mode 100644 core/src/test/resources/config/sample-dbunit.yml diff --git a/README.adoc b/README.adoc index a845a34..7ba6988 100644 --- a/README.adoc +++ b/README.adoc @@ -214,15 +214,15 @@ public class DataSetExecutorIt { @Test public void shouldSeedUserDataSetUsingExecutor() { - DataSetModel dataSetModel = new DataSetModel("datasets/yml/users.yml");<1> - executor.createDataSet(dataSetModel);<2> + DataSetConfig dataSetConfig = new DataSetConfig("datasets/yml/users.yml");<1> + executor.createDataSet(dataSetConfig);<2> User user = (User) em().createQuery("select u from User u where u.id = 1").getSingleResult(); assertThat(user).isNotNull(); assertThat(user.getId()).isEqualTo(1); } } ---- -<1> As we are not using @Rule, which is responsible for reading @DataSet annotation, we have to provide *DataSetModel* so executor can create the dataset. +<1> As we are not using @Rule, which is responsible for reading @DataSet annotation, we have to provide *DataSetConfig* so executor can create the dataset. <2> this is done implicitly by *@Rule DBUnitRule*. DataSet executor setup and logic is `hidden` by DBUnit @Rule and @DataSet annotation: @@ -286,8 +286,8 @@ public class MultipleExecutorsIt { @Test public void shouldSeedUserDataSet() { for (DataSetExecutorImpl executor : executors) { - DataSetModel dataSetModel = new DataSetModel("datasets/yml/users.yml"); - executor.createDataSet(dataSetModel); + DataSetConfig dataSetConfig = new DataSetConfig("datasets/yml/users.yml"); + executor.createDataSet(dataSetConfig); User user = (User) EntityManagerProvider.instance(executor.getId() + "-pu").em().createQuery("select u from User u where u.id = 1").getSingleResult(); assertThat(user).isNotNull(); assertThat(user.getId()).isEqualTo(1); @@ -789,7 +789,7 @@ public class ContactStepsWithoutCDI { @Given("^we have a list of contacts2$") public void given() { - dbunitExecutor.createDataSet(new DataSetModel("contacts.yml")); + dbunitExecutor.createDataSet(new DataSetConfig("contacts.yml")); assertEquals(em().createQuery("select count(c.id) from Contact c").getSingleResult(), new Long(3)); } diff --git a/cdi/src/main/java/com/github/dbunit/rules/cdi/DBUnitInterceptor.java b/cdi/src/main/java/com/github/dbunit/rules/cdi/DBUnitInterceptor.java index c100e9e..eaea2b4 100644 --- a/cdi/src/main/java/com/github/dbunit/rules/cdi/DBUnitInterceptor.java +++ b/cdi/src/main/java/com/github/dbunit/rules/cdi/DBUnitInterceptor.java @@ -1,8 +1,11 @@ package com.github.dbunit.rules.cdi; -import com.github.dbunit.rules.api.dataset.DataSetModel; +import com.github.dbunit.rules.api.configuration.DBUnit; import com.github.dbunit.rules.api.dataset.ExpectedDataSet; import com.github.dbunit.rules.cdi.api.UsingDataSet; +import com.github.dbunit.rules.configuration.DBUnitConfig; +import com.github.dbunit.rules.configuration.DataSetConfig; +import com.github.dbunit.rules.configuration.GlobaConfig; import javax.inject.Inject; import javax.interceptor.AroundInvoke; @@ -31,7 +34,7 @@ public Object intercept(InvocationContext invocationContext) Object proceed = null; UsingDataSet usingDataSet = invocationContext.getMethod().getAnnotation(UsingDataSet.class); if (usingDataSet != null) { - DataSetModel dataSetModel = new DataSetModel(usingDataSet.value()). + DataSetConfig DataSetConfig = new DataSetConfig(usingDataSet.value()). cleanAfter(usingDataSet.cleanAfter()). cleanBefore(usingDataSet.cleanBefore()). disableConstraints(usingDataSet.disableConstraints()). @@ -43,8 +46,8 @@ public Object intercept(InvocationContext invocationContext) transactional(usingDataSet.transactional()). tableOrdering(usingDataSet.tableOrdering()). useSequenceFiltering(usingDataSet.useSequenceFiltering()); - dataSetProcessor.process(dataSetModel); - boolean isTransactionalTest = dataSetModel.isTransactional(); + dataSetProcessor.process(DataSetConfig,resolveDBUnitConfig(invocationContext)); + boolean isTransactionalTest = DataSetConfig.isTransactional(); if(isTransactionalTest){ em.getTransaction().begin(); } @@ -61,14 +64,14 @@ public Object intercept(InvocationContext invocationContext) } ExpectedDataSet expectedDataSet = invocationContext.getMethod().getAnnotation(ExpectedDataSet.class); if(expectedDataSet != null){ - dataSetProcessor.compareCurrentDataSetWith(new DataSetModel(expectedDataSet.value()).disableConstraints(true),expectedDataSet.ignoreCols()); + dataSetProcessor.compareCurrentDataSetWith(new DataSetConfig(expectedDataSet.value()).disableConstraints(true),expectedDataSet.ignoreCols()); } if(usingDataSet.cleanAfter()){ - dataSetProcessor.clearDatabase(dataSetModel); + dataSetProcessor.clearDatabase(DataSetConfig); } if (!"".equals(usingDataSet.executeCommandsAfter())) { - dataSetProcessor.executeStatements(dataSetModel.getExecuteStatementsAfter()); + dataSetProcessor.executeStatements(DataSetConfig.getExecuteStatementsAfter()); } if(usingDataSet.executeScriptsAfter().length > 0 && !"".equals(usingDataSet.executeScriptsAfter()[0])){ @@ -80,7 +83,7 @@ public Object intercept(InvocationContext invocationContext) proceed = invocationContext.proceed(); ExpectedDataSet expectedDataSet = invocationContext.getMethod().getAnnotation(ExpectedDataSet.class); if(expectedDataSet != null){ - dataSetProcessor.compareCurrentDataSetWith(new DataSetModel(expectedDataSet.value()).disableConstraints(true),expectedDataSet.ignoreCols()); + dataSetProcessor.compareCurrentDataSetWith(new DataSetConfig(expectedDataSet.value()).disableConstraints(true),expectedDataSet.ignoreCols()); } } @@ -88,5 +91,18 @@ public Object intercept(InvocationContext invocationContext) return proceed; } + private DBUnitConfig resolveDBUnitConfig(InvocationContext invocationContext) { + DBUnit dbUnitConfig = invocationContext.getMethod().getAnnotation(DBUnit.class); + if (dbUnitConfig == null) { + dbUnitConfig = invocationContext.getMethod().getDeclaringClass().getAnnotation(DBUnit.class); + } + + if (dbUnitConfig != null) { + return DBUnitConfig.from(dbUnitConfig); + } else { + return GlobaConfig.instance().getDbUnitConfig(); + } + } + } diff --git a/cdi/src/main/java/com/github/dbunit/rules/cdi/DataSetProcessor.java b/cdi/src/main/java/com/github/dbunit/rules/cdi/DataSetProcessor.java index 08a1521..b40fdc1 100644 --- a/cdi/src/main/java/com/github/dbunit/rules/cdi/DataSetProcessor.java +++ b/cdi/src/main/java/com/github/dbunit/rules/cdi/DataSetProcessor.java @@ -1,7 +1,8 @@ package com.github.dbunit.rules.cdi; import com.github.dbunit.rules.api.dataset.DataSetExecutor; -import com.github.dbunit.rules.api.dataset.DataSetModel; +import com.github.dbunit.rules.configuration.DBUnitConfig; +import com.github.dbunit.rules.configuration.DataSetConfig; import com.github.dbunit.rules.cdi.api.UsingDataSet; import com.github.dbunit.rules.connection.ConnectionHolderImpl; import com.github.dbunit.rules.dataset.DataSetExecutorImpl; @@ -73,8 +74,9 @@ private Connection createConnection() { return connection; } - public void process(DataSetModel dataSetModel) { - dataSetExecutor.createDataSet(dataSetModel); + public void process(DataSetConfig dataSetConfig, DBUnitConfig config) { + dataSetExecutor.setDbUnitConfig(config); + dataSetExecutor.createDataSet(dataSetConfig); } @@ -87,9 +89,9 @@ private boolean isHibernatePresentOnClasspath() { } } - public void clearDatabase(DataSetModel dataSetModel) { + public void clearDatabase(DataSetConfig DataSetConfig) { try { - dataSetExecutor.clearDatabase(dataSetModel); + dataSetExecutor.clearDatabase(DataSetConfig); } catch (SQLException e) { log.error("Could not clear database.", e); } @@ -103,7 +105,7 @@ public void executeScript(String script) { dataSetExecutor.executeScript(script); } - public void compareCurrentDataSetWith(DataSetModel expected, String[] excludeCols) throws DatabaseUnitException { + public void compareCurrentDataSetWith(DataSetConfig expected, String[] excludeCols) throws DatabaseUnitException { dataSetExecutor.compareCurrentDataSetWith(expected, excludeCols); } diff --git a/core/src/main/java/com/github/dbunit/rules/DBUnitRule.java b/core/src/main/java/com/github/dbunit/rules/DBUnitRule.java index d6e3aaa..0674634 100644 --- a/core/src/main/java/com/github/dbunit/rules/DBUnitRule.java +++ b/core/src/main/java/com/github/dbunit/rules/DBUnitRule.java @@ -1,16 +1,16 @@ package com.github.dbunit.rules; +import com.github.dbunit.rules.api.configuration.DBUnit; import com.github.dbunit.rules.api.connection.ConnectionHolder; import com.github.dbunit.rules.api.dataset.DataSet; import com.github.dbunit.rules.api.dataset.DataSetExecutor; -import com.github.dbunit.rules.api.dataset.DataSetModel; import com.github.dbunit.rules.api.dataset.ExpectedDataSet; -import com.github.dbunit.rules.api.dbunit.DBUnitConfig; -import com.github.dbunit.rules.api.dbunit.DBUnitConfigModel; +import com.github.dbunit.rules.configuration.DBUnitConfig; +import com.github.dbunit.rules.configuration.DataSetConfig; +import com.github.dbunit.rules.configuration.GlobaConfig; import com.github.dbunit.rules.connection.ConnectionHolderImpl; import com.github.dbunit.rules.dataset.DataSetExecutorImpl; import org.dbunit.DatabaseUnitException; -import org.junit.internal.runners.statements.Fail; import org.junit.rules.TestRule; import org.junit.runner.Description; import org.junit.runners.model.Statement; @@ -62,7 +62,7 @@ public void evaluate() throws Throwable { currentMethod = description.getMethodName(); DataSet dataSet = resolveDataSet(description); if (dataSet != null) { - final DataSetModel model = new DataSetModel().from(dataSet); + final DataSetConfig model = new DataSetConfig().from(dataSet); final String datasetExecutorId = model.getExecutorId(); boolean executorNameIsProvided = datasetExecutorId != null && !"".equals(datasetExecutorId.trim()); if (executorNameIsProvided && !executor.getId().equals(datasetExecutorId)) { @@ -72,10 +72,7 @@ public void evaluate() throws Throwable { executor = DataSetExecutorImpl.getExecutorById(datasetExecutorId); } try { - DBUnitConfig dbUnitConfig = resolveDBUnitConfig(description); - if(dbUnitConfig != null && dbUnitConfig.executor().equals(executor.getId())){ - executor.setDbUnitConfig(DBUnitConfigModel.from(dbUnitConfig)); - } + executor.setDbUnitConfig(resolveDBUnitConfig(description)); executor.createDataSet(model); } catch (final Exception e) { throw new RuntimeException("Could not create dataset due to following error " + e.getMessage(), e); @@ -130,10 +127,10 @@ public void evaluate() throws Throwable { } - + }; } - + private DataSet resolveDataSet(Description description) { DataSet dataSet = description.getAnnotation(DataSet.class); if (dataSet == null) { @@ -141,41 +138,46 @@ private DataSet resolveDataSet(Description description) { } return dataSet; } - + private DBUnitConfig resolveDBUnitConfig(Description description) { - DBUnitConfig dbUnitConfig = description.getAnnotation(DBUnitConfig.class); + DBUnit dbUnitConfig = description.getAnnotation(DBUnit.class); if (dbUnitConfig == null) { - dbUnitConfig = description.getTestClass().getAnnotation(DBUnitConfig.class); + dbUnitConfig = description.getTestClass().getAnnotation(DBUnit.class); + } + + if (dbUnitConfig != null) { + return DBUnitConfig.from(dbUnitConfig); + } else { + return GlobaConfig.instance().getDbUnitConfig(); } - return dbUnitConfig; } - private void performDataSetComparison(Description description) throws DatabaseUnitException { - ExpectedDataSet expectedDataSet = description.getAnnotation(ExpectedDataSet.class); - if (expectedDataSet == null) { - //try to infer from class level annotation - expectedDataSet = description.getTestClass().getAnnotation(ExpectedDataSet.class); - } - if (expectedDataSet != null) { - executor.compareCurrentDataSetWith(new DataSetModel(expectedDataSet.value()).disableConstraints(true), expectedDataSet.ignoreCols()); - } - } + private void performDataSetComparison(Description description) throws DatabaseUnitException { + ExpectedDataSet expectedDataSet = description.getAnnotation(ExpectedDataSet.class); + if (expectedDataSet == null) { + //try to infer from class level annotation + expectedDataSet = description.getTestClass().getAnnotation(ExpectedDataSet.class); + } + if (expectedDataSet != null) { + executor.compareCurrentDataSetWith(new DataSetConfig(expectedDataSet.value()).disableConstraints(true), expectedDataSet.ignoreCols()); + } + } - private void init(String name, ConnectionHolder connectionHolder) { - DataSetExecutorImpl instance = DataSetExecutorImpl.getExecutorById(name); - if (instance == null) { - instance = DataSetExecutorImpl.instance(name, connectionHolder); - DataSetExecutorImpl.getExecutors().put(name, instance); - } else{ - instance.setConnectionHolder(connectionHolder); - } - executor = instance; + private void init(String name, ConnectionHolder connectionHolder) { + DataSetExecutorImpl instance = DataSetExecutorImpl.getExecutorById(name); + if (instance == null) { + instance = DataSetExecutorImpl.instance(name, connectionHolder); + DataSetExecutorImpl.getExecutors().put(name, instance); + } else { + instance.setConnectionHolder(connectionHolder); + } + executor = instance; - } + } - public DataSetExecutor getDataSetExecutor() { - return executor; - } + public DataSetExecutor getDataSetExecutor() { + return executor; + } - } \ No newline at end of file +} \ No newline at end of file diff --git a/core/src/main/java/com/github/dbunit/rules/api/dbunit/DBUnitConfig.java b/core/src/main/java/com/github/dbunit/rules/api/configuration/DBUnit.java similarity index 95% rename from core/src/main/java/com/github/dbunit/rules/api/dbunit/DBUnitConfig.java rename to core/src/main/java/com/github/dbunit/rules/api/configuration/DBUnit.java index 2b41318..7d4b0f3 100644 --- a/core/src/main/java/com/github/dbunit/rules/api/dbunit/DBUnitConfig.java +++ b/core/src/main/java/com/github/dbunit/rules/api/configuration/DBUnit.java @@ -1,4 +1,4 @@ -package com.github.dbunit.rules.api.dbunit; +package com.github.dbunit.rules.api.configuration; import com.github.dbunit.rules.dataset.DataSetExecutorImpl; @@ -18,7 +18,7 @@ @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited -public @interface DBUnitConfig { +public @interface DBUnit { /** * diff --git a/core/src/main/java/com/github/dbunit/rules/api/dataset/DataSetExecutor.java b/core/src/main/java/com/github/dbunit/rules/api/dataset/DataSetExecutor.java index 73721db..26184c4 100644 --- a/core/src/main/java/com/github/dbunit/rules/api/dataset/DataSetExecutor.java +++ b/core/src/main/java/com/github/dbunit/rules/api/dataset/DataSetExecutor.java @@ -1,8 +1,9 @@ package com.github.dbunit.rules.api.dataset; import com.github.dbunit.rules.api.connection.ConnectionHolder; -import com.github.dbunit.rules.api.dbunit.DBUnitConfigModel; +import com.github.dbunit.rules.configuration.DBUnitConfig; +import com.github.dbunit.rules.configuration.DataSetConfig; import org.dbunit.DatabaseUnitException; import org.dbunit.dataset.DataSetException; import org.dbunit.dataset.IDataSet; @@ -16,16 +17,16 @@ public interface DataSetExecutor{ /** - * creates a dataset into executor's database connection using given dataSetModel - * @param dataSetModel + * creates a dataset into executor's database connection using given dataSetConfig + * @param dataSetConfig */ - void createDataSet(DataSetModel dataSetModel); + void createDataSet(DataSetConfig dataSetConfig); IDataSet loadDataSet(String name) throws DataSetException, IOException; ConnectionHolder getConnectionHolder(); - void clearDatabase(DataSetModel dataset) throws SQLException; + void clearDatabase(DataSetConfig dataset) throws SQLException; void executeStatements(String[] statements); @@ -38,10 +39,10 @@ public interface DataSetExecutor{ * @param expected * @throws DatabaseUnitException if current dataset is not equal current dataset */ - void compareCurrentDataSetWith(DataSetModel expected, String[] ignoreCols) throws DatabaseUnitException; + void compareCurrentDataSetWith(DataSetConfig expected, String[] ignoreCols) throws DatabaseUnitException; - void setDbUnitConfig(DBUnitConfigModel dbUnitConfig); + void setDbUnitConfig(DBUnitConfig dbUnitConfig); } diff --git a/core/src/main/java/com/github/dbunit/rules/api/dbunit/DBUnitConfigModel.java b/core/src/main/java/com/github/dbunit/rules/api/dbunit/DBUnitConfigModel.java deleted file mode 100644 index 154fd69..0000000 --- a/core/src/main/java/com/github/dbunit/rules/api/dbunit/DBUnitConfigModel.java +++ /dev/null @@ -1,83 +0,0 @@ -package com.github.dbunit.rules.api.dbunit; - -import java.util.HashMap; -import java.util.Map; - -import org.dbunit.database.DatabaseConfig; - -import com.github.dbunit.rules.dataset.DataSetExecutorImpl; - -public class DBUnitConfigModel { - - private String executorId; - - private boolean cacheConnection = false; - - private boolean cacheTables = false; - - private Map dbunitProperties; - - public DBUnitConfigModel(String executor) { - dbunitProperties = new HashMap<>(); - this.executorId = executor; - if("".equals(this.executorId)){ - this.executorId = DataSetExecutorImpl.DEFAULT_EXECUTOR_ID; - } - } - - - public static DBUnitConfigModel from(DBUnitConfig dbUnitConfig){ - DBUnitConfigModel dbUnitConfigModel = new DBUnitConfigModel(dbUnitConfig.executor()); - - dbUnitConfigModel.cacheConnection(dbUnitConfig.cacheConnection()). - cacheTables(dbUnitConfig.cacheTableNames()). - addDBUnitProperty(DatabaseConfig.FEATURE_BATCHED_STATEMENTS, dbUnitConfig.batchedStatements()). - addDBUnitProperty(DatabaseConfig.PROPERTY_BATCH_SIZE, dbUnitConfig.batchSize()). - addDBUnitProperty(DatabaseConfig.FEATURE_ALLOW_EMPTY_FIELDS, dbUnitConfig.allowEmptyFields()). - addDBUnitProperty(DatabaseConfig.PROPERTY_FETCH_SIZE, dbUnitConfig.fetchSize()). - addDBUnitProperty(DatabaseConfig.FEATURE_QUALIFIED_TABLE_NAMES, dbUnitConfig.qualifiedTableNames()); - - if(!"".equals(dbUnitConfig.escapePattern())){ - dbUnitConfigModel.addDBUnitProperty(DatabaseConfig.PROPERTY_ESCAPE_PATTERN, dbUnitConfig.escapePattern()); - } - - return dbUnitConfigModel; - } - - - public DBUnitConfigModel cacheConnection(boolean cacheConnection){ - this.cacheConnection = cacheConnection; - return this; - } - - - public DBUnitConfigModel cacheTables(boolean cacheTables){ - this.cacheTables = cacheTables; - return this; - } - - public DBUnitConfigModel addDBUnitProperty(String name, Object value){ - dbunitProperties.put(name,value); - return this; - } - - public boolean isCacheConnection() { - return cacheConnection; - } - - - public boolean isCacheTables() { - return cacheTables; - } - - - public Map getDbunitProperties() { - return dbunitProperties; - } - - public String getExecutorId() { - return executorId; - } - - -} diff --git a/core/src/main/java/com/github/dbunit/rules/configuration/DBUnitConfig.java b/core/src/main/java/com/github/dbunit/rules/configuration/DBUnitConfig.java new file mode 100644 index 0000000..54f9bbc --- /dev/null +++ b/core/src/main/java/com/github/dbunit/rules/configuration/DBUnitConfig.java @@ -0,0 +1,103 @@ +package com.github.dbunit.rules.configuration; + +import com.github.dbunit.rules.api.configuration.DBUnit; +import com.github.dbunit.rules.dataset.DataSetExecutorImpl; +import org.dbunit.database.DatabaseConfig; + +import java.util.HashMap; +import java.util.Map; + +/** + * + * represents DBUnit configuration of a dataset executor. + */ +public class DBUnitConfig { + + private String executorId; + + private boolean cacheConnection = false; + + private boolean cacheTables = false; + + private Map properties; + + public DBUnitConfig() { + this.executorId = DataSetExecutorImpl.DEFAULT_EXECUTOR_ID; + } + + public DBUnitConfig(String executor) { + properties = new HashMap<>(); + this.executorId = executor; + if("".equals(this.executorId)){ + this.executorId = DataSetExecutorImpl.DEFAULT_EXECUTOR_ID; + } + } + + + public static DBUnitConfig from(DBUnit dbUnit){ + DBUnitConfig dbUnitConfig = new DBUnitConfig(dbUnit.executor()); + + dbUnitConfig.cacheConnection(dbUnit.cacheConnection()). + cacheTables(dbUnit.cacheTableNames()). + addDBUnitProperty("batchedStatements", dbUnit.batchedStatements()). + addDBUnitProperty("batchSize", dbUnit.batchSize()). + addDBUnitProperty("allowEmptyFields", dbUnit.allowEmptyFields()). + addDBUnitProperty("fetchSize", dbUnit.fetchSize()). + addDBUnitProperty("qualifiedTableNames", dbUnit.qualifiedTableNames()); + + if(!"".equals(dbUnit.escapePattern())){ + dbUnitConfig.addDBUnitProperty("escapePattern", dbUnit.escapePattern()); + } + + return dbUnitConfig; + } + + + public DBUnitConfig cacheConnection(boolean cacheConnection){ + this.cacheConnection = cacheConnection; + return this; + } + + + public DBUnitConfig cacheTables(boolean cacheTables){ + this.cacheTables = cacheTables; + return this; + } + + public DBUnitConfig addDBUnitProperty(String name, Object value){ + properties.put(name, value); + return this; + } + + public void setCacheConnection(boolean cacheConnection) { + this.cacheConnection = cacheConnection; + } + + public void setProperties(Map properties) { + this.properties = properties; + } + + public void setCacheTables(boolean cacheTables) { + this.cacheTables = cacheTables; + } + + public boolean isCacheConnection() { + return cacheConnection; + } + + + public boolean isCacheTables() { + return cacheTables; + } + + + public Map getProperties() { + return properties; + } + + public String getExecutorId() { + return executorId; + } + + +} diff --git a/core/src/main/java/com/github/dbunit/rules/api/dataset/DataSetModel.java b/core/src/main/java/com/github/dbunit/rules/configuration/DataSetConfig.java similarity index 66% rename from core/src/main/java/com/github/dbunit/rules/api/dataset/DataSetModel.java rename to core/src/main/java/com/github/dbunit/rules/configuration/DataSetConfig.java index 220a02d..02f525c 100644 --- a/core/src/main/java/com/github/dbunit/rules/api/dataset/DataSetModel.java +++ b/core/src/main/java/com/github/dbunit/rules/configuration/DataSetConfig.java @@ -1,182 +1,208 @@ -package com.github.dbunit.rules.api.dataset; - -import com.github.dbunit.rules.dataset.DataSetExecutorImpl; - -/** - * Created by pestano on 26/07/15. - */ -public class DataSetModel { - - private String name; - private String executorId = DataSetExecutorImpl.DEFAULT_EXECUTOR_ID; - private SeedStrategy seedStrategy = SeedStrategy.CLEAN_INSERT; - private boolean useSequenceFiltering = true; - private boolean disableConstraints = false; - private boolean cleanBefore = false; - private boolean cleanAfter = false; - private boolean transactional = false; - private String[] tableOrdering = {}; - private String[] executeStatementsBefore = {}; - private String[] executeStatementsAfter = {}; - private String[] executeScriptsBefore = {}; - private String[] executeScriptsAfter = {}; - - - public DataSetModel() { - } - - public DataSetModel(String name) { - this.name = name; - } - - public DataSetModel name(String name) { - this.name = name; - return this; - } - - public DataSetModel seedStrategy(SeedStrategy seedStrategy) { - this.seedStrategy = seedStrategy; - return this; - } - - public DataSetModel useSequenceFiltering(boolean useSequenceFiltering) { - this.useSequenceFiltering = useSequenceFiltering; - return this; - } - - public DataSetModel disableConstraints(boolean disableConstraints) { - this.disableConstraints = disableConstraints; - return this; - } - - public DataSetModel tableOrdering(String[] tableOrdering) { - this.tableOrdering = tableOrdering; - return this; - } - - public DataSetModel cleanBefore(boolean cleanBefore) { - this.cleanBefore = cleanBefore; - return this; - } - - public DataSetModel cleanAfter(boolean cleanAfter) { - this.cleanAfter = cleanAfter; - return this; - } - - public DataSetModel executeStatementsBefore(String[] executeStatementsBefore) { - this.executeStatementsBefore = executeStatementsBefore; - return this; - } - - public DataSetModel executeStatementsAfter(String[] executeStatementsAfter) { - this.executeStatementsAfter = executeStatementsAfter; - return this; - } - - public DataSetModel executeScripsBefore(String[] executeScriptsBefore) { - this.executeScriptsBefore = executeScriptsBefore; - return this; - } - - public DataSetModel executeScriptsAfter(String[] executeScriptsAfter) { - this.executeScriptsAfter = executeScriptsAfter; - return this; - } - - /** - * name of dataset executor for the given dataset. If not specified the default one will be used. - * - * Use this option to work with multple database conncetions. Remember that each executor has its own connection. - * @return datasetModel with executor name configured - */ - public DataSetModel executorId(String executorId) { - this.executorId = executorId; - return this; - } - - public DataSetModel transactional(boolean transactional){ - this.transactional = transactional; - return this; - } - - - public DataSetModel from(DataSet dataSet) { - if(dataSet != null){ - return name(dataSet.value()).seedStrategy(dataSet.strategy()). - useSequenceFiltering(dataSet.useSequenceFiltering()). - tableOrdering(dataSet.tableOrdering()). - disableConstraints(dataSet.disableConstraints()). - executorId(dataSet.executorId()). - executeStatementsBefore(dataSet.executeStatementsBefore()). - executeScripsBefore(dataSet.executeScriptsBefore()). - cleanBefore(dataSet.cleanBefore()). - cleanAfter(dataSet.cleanAfter()). - transactional(dataSet.transactional()). - executeStatementsAfter(dataSet.executeStatementsAfter()). - executeScriptsAfter(dataSet.executeScriptsAfter()); - } else{ - throw new RuntimeException("Cannot create DataSetModel from Null DataSet"); - } - - } - - - - public String getName() { - return name; - } - - public SeedStrategy getSeedStrategy() { - return seedStrategy; - } - - public boolean isUseSequenceFiltering() { - return useSequenceFiltering; - } - - public boolean isDisableConstraints() { - return disableConstraints; - } - - public boolean isTransactional() { - return transactional; - } - - public String[] getTableOrdering() { - return tableOrdering; - } - - public String[] getExecuteStatementsBefore() { - return executeStatementsBefore; - } - - public String[] getExecuteStatementsAfter() { - return executeStatementsAfter; - } - - public String[] getExecuteScriptsBefore() { - return executeScriptsBefore; - } - - public String[] getExecuteScriptsAfter() { - return executeScriptsAfter; - } - - public String getExecutorId() { - return executorId; - } - - public boolean isCleanBefore() { - return cleanBefore; - } - - public boolean isCleanAfter() { - return cleanAfter; - } - - @Override - public String toString() { - return name; - } -} +package com.github.dbunit.rules.configuration; + +import com.github.dbunit.rules.api.dataset.DataSet; +import com.github.dbunit.rules.api.dataset.SeedStrategy; +import com.github.dbunit.rules.dataset.DataSetExecutorImpl; + +/** + * Created by pestano on 26/07/15. + */ +public class DataSetConfig { + + private String name; + private String executorId = DataSetExecutorImpl.DEFAULT_EXECUTOR_ID; + private SeedStrategy seedStrategy = SeedStrategy.CLEAN_INSERT; + private boolean useSequenceFiltering = true; + private boolean disableConstraints = false; + private boolean cleanBefore = false; + private boolean cleanAfter = false; + private boolean transactional = false; + private String[] tableOrdering = {}; + private String[] executeStatementsBefore = {}; + private String[] executeStatementsAfter = {}; + private String[] executeScriptsBefore = {}; + private String[] executeScriptsAfter = {}; + + + public DataSetConfig() { + //loadDefaultConfiguration(); + } + + public DataSetConfig(String name) { + this.name = name; + } + + public DataSetConfig name(String name) { + this.name = name; + return this; + } + + public DataSetConfig seedStrategy(SeedStrategy seedStrategy) { + this.seedStrategy = seedStrategy; + return this; + } + + public DataSetConfig useSequenceFiltering(boolean useSequenceFiltering) { + this.useSequenceFiltering = useSequenceFiltering; + return this; + } + + public DataSetConfig disableConstraints(boolean disableConstraints) { + this.disableConstraints = disableConstraints; + return this; + } + + public DataSetConfig tableOrdering(String[] tableOrdering) { + this.tableOrdering = tableOrdering; + return this; + } + + public DataSetConfig cleanBefore(boolean cleanBefore) { + this.cleanBefore = cleanBefore; + return this; + } + + public DataSetConfig cleanAfter(boolean cleanAfter) { + this.cleanAfter = cleanAfter; + return this; + } + + public DataSetConfig executeStatementsBefore(String[] executeStatementsBefore) { + this.executeStatementsBefore = executeStatementsBefore; + return this; + } + + public DataSetConfig executeStatementsAfter(String[] executeStatementsAfter) { + this.executeStatementsAfter = executeStatementsAfter; + return this; + } + + public DataSetConfig executeScripsBefore(String[] executeScriptsBefore) { + this.executeScriptsBefore = executeScriptsBefore; + return this; + } + + public DataSetConfig executeScriptsAfter(String[] executeScriptsAfter) { + this.executeScriptsAfter = executeScriptsAfter; + return this; + } + + /** + * name of dataset executor for the given dataset. If not specified the default one will be used. + * + * Use this option to work with multple database conncetions. Remember that each executor has its own connection. + * @return DataSetConfig with executor name configured + */ + public DataSetConfig executorId(String executorId) { + this.executorId = executorId; + return this; + } + + public DataSetConfig transactional(boolean transactional){ + this.transactional = transactional; + return this; + } + + + public DataSetConfig from(DataSet dataSet) { + if(dataSet != null){ + return name(dataSet.value()).seedStrategy(dataSet.strategy()). + useSequenceFiltering(dataSet.useSequenceFiltering()). + tableOrdering(dataSet.tableOrdering()). + disableConstraints(dataSet.disableConstraints()). + executorId(dataSet.executorId()). + executeStatementsBefore(dataSet.executeStatementsBefore()). + executeScripsBefore(dataSet.executeScriptsBefore()). + cleanBefore(dataSet.cleanBefore()). + cleanAfter(dataSet.cleanAfter()). + transactional(dataSet.transactional()). + executeStatementsAfter(dataSet.executeStatementsAfter()). + executeScriptsAfter(dataSet.executeScriptsAfter()); + } else{ + throw new RuntimeException("Cannot create DataSetConfig from Null DataSet"); + } + + } + + + public String getName() { + return name; + } + + public SeedStrategy getSeedStrategy() { + return seedStrategy; + } + + public boolean isUseSequenceFiltering() { + return useSequenceFiltering; + } + + public boolean isDisableConstraints() { + return disableConstraints; + } + + public boolean isTransactional() { + return transactional; + } + + public String[] getTableOrdering() { + return tableOrdering; + } + + public String[] getExecuteStatementsBefore() { + return executeStatementsBefore; + } + + public String[] getExecuteStatementsAfter() { + return executeStatementsAfter; + } + + public String[] getExecuteScriptsBefore() { + return executeScriptsBefore; + } + + public String[] getExecuteScriptsAfter() { + return executeScriptsAfter; + } + + public String getExecutorId() { + return executorId; + } + + public boolean isCleanBefore() { + return cleanBefore; + } + + public boolean isCleanAfter() { + return cleanAfter; + } + + public void setSeedStrategy(SeedStrategy seedStrategy) { + this.seedStrategy = seedStrategy; + } + + public void setUseSequenceFiltering(boolean useSequenceFiltering) { + this.useSequenceFiltering = useSequenceFiltering; + } + + public void setDisableConstraints(boolean disableConstraints) { + this.disableConstraints = disableConstraints; + } + + public void setCleanBefore(boolean cleanBefore) { + this.cleanBefore = cleanBefore; + } + + public void setCleanAfter(boolean cleanAfter) { + this.cleanAfter = cleanAfter; + } + + public void setTransactional(boolean transactional) { + this.transactional = transactional; + } + + @Override + public String toString() { + return name; + } +} diff --git a/core/src/main/java/com/github/dbunit/rules/configuration/GlobaConfig.java b/core/src/main/java/com/github/dbunit/rules/configuration/GlobaConfig.java new file mode 100644 index 0000000..808ed04 --- /dev/null +++ b/core/src/main/java/com/github/dbunit/rules/configuration/GlobaConfig.java @@ -0,0 +1,63 @@ +package com.github.dbunit.rules.configuration; + +import org.yaml.snakeyaml.Yaml; + +import java.io.InputStream; + +/** + * Created by pestano on 03/09/16. + * + * pojo which represents dbunit.yml, used for global which can be overrided via @DataSet annotation + * at class or method level and with @DBUnit at class or method level + */ +public class GlobaConfig { + + private static GlobaConfig instance; + + private DBUnitConfig dbUnitConfig; + + + private GlobaConfig() { + + } + + public void setDbUnitConfig(DBUnitConfig dbUnitConfig) { + this.dbUnitConfig = dbUnitConfig; + } + + public static GlobaConfig instance() { + if (instance == null) { + createInstance(); + } + if(instance.getDbUnitConfig().getProperties().containsKey("escapePattern")){ + if (instance.getDbUnitConfig().getProperties().get("escapePattern").equals("")){ + //avoid Caused by: org.dbunit.DatabaseUnitRuntimeException: Empty string is an invalid escape pattern! + // because @DBUnit annotation and dbunit.yml global config have escapePattern defaults to "" + instance.getDbUnitConfig().getProperties().remove("escapePattern"); + } + } + return instance; + } + + public static GlobaConfig newInstance() { + instance = null; + return instance(); + } + + private static void createInstance() { + //try to instance user provided dbunit.yml + InputStream customConfiguration = Thread.currentThread().getContextClassLoader().getResourceAsStream("dbunit.yml"); + if(customConfiguration != null){ + instance = new Yaml().loadAs(customConfiguration, GlobaConfig.class); + } else{ + //default config + instance = new Yaml().loadAs(GlobaConfig.class.getResourceAsStream("/default/dbunit.yml"), GlobaConfig.class); + } + + } + + public DBUnitConfig getDbUnitConfig() { + return dbUnitConfig; + } + +} diff --git a/core/src/main/java/com/github/dbunit/rules/dataset/DataSetExecutorImpl.java b/core/src/main/java/com/github/dbunit/rules/dataset/DataSetExecutorImpl.java index 702ed45..5f82fc7 100644 --- a/core/src/main/java/com/github/dbunit/rules/dataset/DataSetExecutorImpl.java +++ b/core/src/main/java/com/github/dbunit/rules/dataset/DataSetExecutorImpl.java @@ -1,30 +1,21 @@ package com.github.dbunit.rules.dataset; -import java.io.File; -import java.io.IOException; -import java.io.InputStream; -import java.io.RandomAccessFile; -import java.net.URL; -import java.sql.Connection; -import java.sql.DatabaseMetaData; -import java.sql.ResultSet; -import java.sql.SQLException; -import java.util.ArrayList; -import java.util.List; -import java.util.Map; -import java.util.Map.Entry; -import java.util.concurrent.ConcurrentHashMap; - +import com.github.dbunit.rules.api.connection.ConnectionHolder; +import com.github.dbunit.rules.api.dataset.DataSetExecutor; +import com.github.dbunit.rules.api.dataset.JSONDataSet; +import com.github.dbunit.rules.api.dataset.YamlDataSet; +import com.github.dbunit.rules.assertion.DataSetAssertion; +import com.github.dbunit.rules.configuration.DBUnitConfig; +import com.github.dbunit.rules.configuration.DataSetConfig; +import com.github.dbunit.rules.exception.DataBaseSeedingException; +import com.github.dbunit.rules.replacer.DateTimeReplacer; +import com.github.dbunit.rules.replacer.ScriptReplacer; import org.dbunit.DatabaseUnitException; import org.dbunit.database.AmbiguousTableNameException; import org.dbunit.database.DatabaseConfig; import org.dbunit.database.DatabaseConnection; import org.dbunit.database.DatabaseSequenceFilter; -import org.dbunit.dataset.CompositeDataSet; -import org.dbunit.dataset.DataSetException; -import org.dbunit.dataset.FilteredDataSet; -import org.dbunit.dataset.IDataSet; -import org.dbunit.dataset.ITable; +import org.dbunit.dataset.*; import org.dbunit.dataset.csv.CsvDataSet; import org.dbunit.dataset.excel.XlsDataSet; import org.dbunit.dataset.filter.DefaultColumnFilter; @@ -40,16 +31,20 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import com.github.dbunit.rules.api.connection.ConnectionHolder; -import com.github.dbunit.rules.api.dataset.DataSetExecutor; -import com.github.dbunit.rules.api.dataset.DataSetModel; -import com.github.dbunit.rules.api.dataset.JSONDataSet; -import com.github.dbunit.rules.api.dataset.YamlDataSet; -import com.github.dbunit.rules.api.dbunit.DBUnitConfigModel; -import com.github.dbunit.rules.assertion.DataSetAssertion; -import com.github.dbunit.rules.exception.DataBaseSeedingException; -import com.github.dbunit.rules.replacer.DateTimeReplacer; -import com.github.dbunit.rules.replacer.ScriptReplacer; +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.io.RandomAccessFile; +import java.net.URL; +import java.sql.Connection; +import java.sql.DatabaseMetaData; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.concurrent.ConcurrentHashMap; /** * Created by pestano on 26/07/15. @@ -62,7 +57,7 @@ public class DataSetExecutorImpl implements DataSetExecutor { private static Map executors = new ConcurrentHashMap<>(); - private DBUnitConfigModel dbUnitConfig; + private DBUnitConfig dbUnitConfig; private static String SEQUENCE_TABLE_NAME; @@ -98,7 +93,7 @@ public static DataSetExecutorImpl instance(String executorId, ConnectionHolder c } DataSetExecutorImpl instance = executors.get(executorId); if (instance == null) { - instance = new DataSetExecutorImpl(executorId, connectionHolder, new DBUnitConfigModel(executorId)); + instance = new DataSetExecutorImpl(executorId, connectionHolder, new DBUnitConfig(executorId)); log.debug("creating executor instance " + executorId); executors.put(executorId, instance); } else { @@ -107,58 +102,58 @@ public static DataSetExecutorImpl instance(String executorId, ConnectionHolder c return instance; } - private DataSetExecutorImpl(String executorId, ConnectionHolder connectionHolder, DBUnitConfigModel dbUnitConfigModel) { + private DataSetExecutorImpl(String executorId, ConnectionHolder connectionHolder, DBUnitConfig dbUnitConfig) { this.connectionHolder = connectionHolder; this.id = executorId; - this.dbUnitConfig = dbUnitConfigModel; + this.dbUnitConfig = dbUnitConfig; } @Override - public void createDataSet(DataSetModel dataSetModel) { + public void createDataSet(DataSetConfig dataSetConfig) { - if (dataSetModel != null) { + if (dataSetConfig != null) { try { if(databaseConnection == null || !dbUnitConfig.isCacheConnection()){ initDatabaseConnection(); } - if (dataSetModel.isDisableConstraints()) { + if (dataSetConfig.isDisableConstraints()) { disableConstraints(); } - if (dataSetModel.isCleanBefore()) { + if (dataSetConfig.isCleanBefore()) { try { - clearDatabase(dataSetModel); + clearDatabase(dataSetConfig); } catch (SQLException e) { LoggerFactory.getLogger(DataSetExecutorImpl.class.getName()).warn("Could not clean database before test.", e); } } - if (dataSetModel.getExecuteStatementsBefore() != null && dataSetModel.getExecuteStatementsBefore().length > 0) { - executeStatements(dataSetModel.getExecuteStatementsBefore()); + if (dataSetConfig.getExecuteStatementsBefore() != null && dataSetConfig.getExecuteStatementsBefore().length > 0) { + executeStatements(dataSetConfig.getExecuteStatementsBefore()); } - if (dataSetModel.getExecuteScriptsBefore() != null && dataSetModel.getExecuteScriptsBefore().length > 0) { - for (int i = 0; i < dataSetModel.getExecuteScriptsBefore().length; i++) { - executeScript(dataSetModel.getExecuteScriptsBefore()[i]); + if (dataSetConfig.getExecuteScriptsBefore() != null && dataSetConfig.getExecuteScriptsBefore().length > 0) { + for (int i = 0; i < dataSetConfig.getExecuteScriptsBefore().length; i++) { + executeScript(dataSetConfig.getExecuteScriptsBefore()[i]); } } - if (dataSetModel.getName() != null && !"".equals(dataSetModel.getName())) { - IDataSet resultingDataSet = loadDataSet(dataSetModel.getName()); + if (dataSetConfig.getName() != null && !"".equals(dataSetConfig.getName())) { + IDataSet resultingDataSet = loadDataSet(dataSetConfig.getName()); - resultingDataSet = performSequenceFiltering(dataSetModel, resultingDataSet); + resultingDataSet = performSequenceFiltering(dataSetConfig, resultingDataSet); - resultingDataSet = performTableOrdering(dataSetModel, resultingDataSet); + resultingDataSet = performTableOrdering(dataSetConfig, resultingDataSet); resultingDataSet = performReplacements(resultingDataSet); - DatabaseOperation operation = dataSetModel.getSeedStrategy().getOperation(); + DatabaseOperation operation = dataSetConfig.getSeedStrategy().getOperation(); operation.execute(databaseConnection, resultingDataSet); } } catch (Exception e) { - throw new DataBaseSeedingException("Could not initialize dataset: " + dataSetModel, e); + throw new DataBaseSeedingException("Could not initialize dataset: " + dataSetConfig, e); } @@ -166,7 +161,7 @@ public void createDataSet(DataSetModel dataSetModel) { } /** - * @param name one or more (comma separated) dataset names to load + * @param name one or more (comma separated) dataset names to instance * @return loaded dataset (in case of multiple dataSets they will be merged in one using composite dataset) */ public IDataSet loadDataSet(String name) throws DataSetException, IOException { @@ -219,14 +214,14 @@ public ConnectionHolder getConnectionHolder() { return connectionHolder; } - private IDataSet performTableOrdering(DataSetModel dataSet, IDataSet target) throws AmbiguousTableNameException { + private IDataSet performTableOrdering(DataSetConfig dataSet, IDataSet target) throws AmbiguousTableNameException { if (dataSet.getTableOrdering().length > 0) { target = new FilteredDataSet(new SequenceTableFilter(dataSet.getTableOrdering()), target); } return target; } - private IDataSet performSequenceFiltering(DataSetModel dataSet, IDataSet target) throws DataSetException, SQLException { + private IDataSet performSequenceFiltering(DataSetConfig dataSet, IDataSet target) throws DataSetException, SQLException { if (dataSet.isUseSequenceFiltering()) { ITableFilter filteredTable = new DatabaseSequenceFilter(databaseConnection, target.getTableNames()); target = new FilteredDataSet(filteredTable, target); @@ -237,8 +232,8 @@ private IDataSet performSequenceFiltering(DataSetModel dataSet, IDataSet target) private void configDatabaseProperties() throws SQLException { DatabaseConfig config = databaseConnection.getConfig(); - for (Entry p : dbUnitConfig.getDbunitProperties().entrySet()) { - config.setProperty(p.getKey(),p.getValue()); + for (Entry p : dbUnitConfig.getProperties().entrySet()) { + config.setProperty(DatabaseConfig.findByShortName(p.getKey()).getProperty(),p.getValue()); } @@ -411,7 +406,7 @@ private InputStream getDataSetStream(String dataSet) { /** * @throws SQLException */ - public void clearDatabase(DataSetModel dataset) throws SQLException { + public void clearDatabase(DataSetConfig dataset) throws SQLException { Connection connection = connectionHolder.getConnection(); if (dataset != null && dataset.getTableOrdering() != null && dataset.getTableOrdering().length > 0) { @@ -544,7 +539,7 @@ private String[] readScriptStatements(File scriptFile) { } - public void compareCurrentDataSetWith(DataSetModel expectedDataSetModel, String[] excludeCols) throws DatabaseUnitException { + public void compareCurrentDataSetWith(DataSetConfig expectedDataSetConfig, String[] excludeCols) throws DatabaseUnitException { IDataSet current = null; IDataSet expected = null; try { @@ -553,7 +548,7 @@ public void compareCurrentDataSetWith(DataSetModel expectedDataSetModel, String[ initDatabaseConnection(); } current = databaseConnection.createDataSet(); - expected = loadDataSet(expectedDataSetModel.getName()); + expected = loadDataSet(expectedDataSetConfig.getName()); } catch (Exception e) { throw new RuntimeException("Could not create dataset to compare.", e); } @@ -579,7 +574,7 @@ public void compareCurrentDataSetWith(DataSetModel expectedDataSetModel, String[ } - public void setDbUnitConfig(DBUnitConfigModel dbUnitConfig) { + public void setDbUnitConfig(DBUnitConfig dbUnitConfig) { this.dbUnitConfig = dbUnitConfig; } diff --git a/core/src/main/resources/default/dbunit.yml b/core/src/main/resources/default/dbunit.yml new file mode 100644 index 0000000..1351366 --- /dev/null +++ b/core/src/main/resources/default/dbunit.yml @@ -0,0 +1,10 @@ +dbUnitConfig: + cacheConnection: false + cacheTables: false + properties: + batchedStatements: false + qualifiedTableNames: false + batchSize: 100 + fetchSize: 100 + allowEmptyFields: false + escapePattern: "" diff --git a/core/src/test/java/com/github/dbunit/rules/DBUnitClassLevelAnnotationIt.java b/core/src/test/java/com/github/dbunit/rules/DBUnitClassLevelAnnotationIt.java index aaf0aec..816f7b6 100644 --- a/core/src/test/java/com/github/dbunit/rules/DBUnitClassLevelAnnotationIt.java +++ b/core/src/test/java/com/github/dbunit/rules/DBUnitClassLevelAnnotationIt.java @@ -1,7 +1,7 @@ package com.github.dbunit.rules; import com.github.dbunit.rules.api.dataset.DataSet; -import com.github.dbunit.rules.api.dbunit.DBUnitConfig; +import com.github.dbunit.rules.api.configuration.DBUnit; import com.github.dbunit.rules.model.Follower; import com.github.dbunit.rules.model.User; import com.github.dbunit.rules.util.EntityManagerProvider; @@ -18,7 +18,7 @@ */ @RunWith(JUnit4.class) @DataSet(value = "datasets/yml/users.yml") -@DBUnitConfig(cacheConnection = true) +@DBUnit(cacheConnection = true) public class DBUnitClassLevelAnnotationIt { @Rule diff --git a/core/src/test/java/com/github/dbunit/rules/DBUnitRulesIt.java b/core/src/test/java/com/github/dbunit/rules/DBUnitRulesIt.java index 4d31838..b9dea0f 100644 --- a/core/src/test/java/com/github/dbunit/rules/DBUnitRulesIt.java +++ b/core/src/test/java/com/github/dbunit/rules/DBUnitRulesIt.java @@ -2,7 +2,7 @@ import com.github.dbunit.rules.api.dataset.DataSet; import com.github.dbunit.rules.api.dataset.SeedStrategy; -import com.github.dbunit.rules.api.dbunit.DBUnitConfig; +import com.github.dbunit.rules.api.configuration.DBUnit; import com.github.dbunit.rules.dataset.DataSetExecutorImpl; import com.github.dbunit.rules.model.Follower; import com.github.dbunit.rules.model.Tweet; @@ -28,7 +28,7 @@ @RunWith(JUnit4.class) -@DBUnitConfig(cacheConnection = true, cacheTableNames = true) +@DBUnit(cacheConnection = true, cacheTableNames = true) public class DBUnitRulesIt { // tag::rules[] diff --git a/core/src/test/java/com/github/dbunit/rules/DataSetExecutorIt.java b/core/src/test/java/com/github/dbunit/rules/DataSetExecutorIt.java index 5d87572..0edf3a7 100644 --- a/core/src/test/java/com/github/dbunit/rules/DataSetExecutorIt.java +++ b/core/src/test/java/com/github/dbunit/rules/DataSetExecutorIt.java @@ -11,7 +11,7 @@ import com.github.dbunit.rules.connection.ConnectionHolderImpl; import com.github.dbunit.rules.dataset.DataSetExecutorImpl; -import com.github.dbunit.rules.api.dataset.DataSetModel; +import com.github.dbunit.rules.configuration.DataSetConfig; import com.github.dbunit.rules.exception.DataBaseSeedingException; import com.github.dbunit.rules.util.EntityManagerProvider; import org.junit.*; @@ -47,8 +47,8 @@ public static void tearDown() throws SQLException { @Test public void shouldSeedDataSetDisablingContraints() { - DataSetModel dataSetModel = new DataSetModel("datasets/yml/users.yml").disableConstraints(true); - executor.createDataSet(dataSetModel); + DataSetConfig DataSetConfig = new DataSetConfig("datasets/yml/users.yml").disableConstraints(true); + executor.createDataSet(DataSetConfig); User user = (User) em().createQuery("select u from User u where u.id = 1").getSingleResult(); assertThat(user).isNotNull(); assertThat(user.getId()).isEqualTo(1); @@ -56,8 +56,8 @@ public void shouldSeedDataSetDisablingContraints() { @Test public void shouldSeedDataSetDisablingContraintsViaStatement() { - DataSetModel dataSetModel = new DataSetModel("datasets/yml/users.yml").executeStatementsAfter(new String[]{"SET DATABASE REFERENTIAL INTEGRITY FALSE;"}); - executor.createDataSet(dataSetModel); + DataSetConfig DataSetConfig = new DataSetConfig("datasets/yml/users.yml").executeStatementsAfter(new String[]{"SET DATABASE REFERENTIAL INTEGRITY FALSE;"}); + executor.createDataSet(DataSetConfig); User user = (User) em().createQuery("select u from User u where u.id = 1").getSingleResult(); assertThat(user).isNotNull(); assertThat(user.getId()).isEqualTo(1); @@ -66,11 +66,11 @@ public void shouldSeedDataSetDisablingContraintsViaStatement() { @Test public void shouldNotSeedDataSetWithoutSequenceFilter() { - DataSetModel dataSetModel = new DataSetModel("datasets/yml/users.yml"). + DataSetConfig DataSetConfig = new DataSetConfig("datasets/yml/users.yml"). useSequenceFiltering(false). executeStatementsAfter(new String[] { "DELETE FROM User" });//needed because other tests creates users and as the dataset is not created in this test the CLEAN is not performed try { - executor.createDataSet(dataSetModel); + executor.createDataSet(DataSetConfig); }catch (DataBaseSeedingException e){ assertThat(e.getMessage()).isEqualTo("Could not initialize dataset: datasets/yml/users.yml"); } @@ -78,20 +78,20 @@ public void shouldNotSeedDataSetWithoutSequenceFilter() { @Test public void shouldSeedDataSetUsingTableCreationOrder() { - DataSetModel dataSetModel = new DataSetModel("datasets/yml/users.yml"). + DataSetConfig DataSetConfig = new DataSetConfig("datasets/yml/users.yml"). tableOrdering(new String[]{"USER","TWEET","FOLLOWER"}). executeStatementsBefore(new String[]{"DELETE FROM FOLLOWER","DELETE FROM TWEET","DELETE FROM USER"}).//needed because other tests created user dataset useSequenceFiltering(false); - DataSetExecutorImpl.instance(new ConnectionHolderImpl(emProvider.connection())).createDataSet(dataSetModel); + DataSetExecutorImpl.instance(new ConnectionHolderImpl(emProvider.connection())).createDataSet(DataSetConfig); List users = em().createQuery("select u from User u").getResultList(); assertThat(users).hasSize(2); } @Test public void shouldSeedUserDataSet() { - DataSetModel dataSetModel = new DataSetModel("datasets/yml/users.yml"). + DataSetConfig DataSetConfig = new DataSetConfig("datasets/yml/users.yml"). useSequenceFiltering(true); - executor.createDataSet(dataSetModel); + executor.createDataSet(DataSetConfig); User user = (User) em().createQuery("select u from User u where u.id = 1").getSingleResult(); assertThat(user).isNotNull(); assertThat(user.getId()).isEqualTo(1); @@ -99,8 +99,8 @@ public void shouldSeedUserDataSet() { @Test public void shouldLoadUserFollowers() { - DataSetModel dataSetModel = new DataSetModel("datasets/yml/users.yml"); - executor.createDataSet(dataSetModel); + DataSetConfig DataSetConfig = new DataSetConfig("datasets/yml/users.yml"); + executor.createDataSet(DataSetConfig); User user = (User) em().createQuery("select u from User u left join fetch u.followers where u.id = 1").getSingleResult(); assertThat(user).isNotNull(); assertThat(user.getId()).isEqualTo(1); @@ -113,8 +113,8 @@ public void shouldLoadUserFollowers() { @Test public void shouldLoadUsersFromJsonDataset() { - DataSetModel dataSetModel = new DataSetModel("datasets/json/users.json"); - executor.createDataSet(dataSetModel); + DataSetConfig DataSetConfig = new DataSetConfig("datasets/json/users.json"); + executor.createDataSet(DataSetConfig); User user = (User) emProvider.clear().em().createQuery("select u from User u left join fetch u.followers where u.id = 1").getSingleResult(); assertThat(user).isNotNull(); assertThat(user.getId()).isEqualTo(1); @@ -127,8 +127,8 @@ public void shouldLoadUsersFromJsonDataset() { @Test public void shouldLoadUsersFromXmlDataset() { - DataSetModel dataSetModel = new DataSetModel("datasets/xml/users.xml"); - executor.createDataSet(dataSetModel); + DataSetConfig DataSetConfig = new DataSetConfig("datasets/xml/users.xml"); + executor.createDataSet(DataSetConfig); User user = (User) emProvider.clear().em().createQuery("select u from User u left join fetch u.followers where u.id = 1").getSingleResult(); assertThat(user).isNotNull(); assertThat(user.getId()).isEqualTo(1); diff --git a/core/src/test/java/com/github/dbunit/rules/DateReplacementsIt.java b/core/src/test/java/com/github/dbunit/rules/DateReplacementsIt.java index 9c29cf7..e923a3e 100644 --- a/core/src/test/java/com/github/dbunit/rules/DateReplacementsIt.java +++ b/core/src/test/java/com/github/dbunit/rules/DateReplacementsIt.java @@ -1,7 +1,7 @@ package com.github.dbunit.rules; import com.github.dbunit.rules.api.dataset.DataSet; -import com.github.dbunit.rules.api.dbunit.DBUnitConfig; +import com.github.dbunit.rules.api.configuration.DBUnit; import com.github.dbunit.rules.model.Tweet; import com.github.dbunit.rules.util.EntityManagerProvider; import org.junit.Before; @@ -15,7 +15,7 @@ /** * Created by pestano on 15/02/16. */ -@DBUnitConfig(cacheConnection = true) +@DBUnit(cacheConnection = true) public class DateReplacementsIt { Calendar now; diff --git a/core/src/test/java/com/github/dbunit/rules/EmptyDataSetIt.java b/core/src/test/java/com/github/dbunit/rules/EmptyDataSetIt.java index 52cc510..1225d58 100644 --- a/core/src/test/java/com/github/dbunit/rules/EmptyDataSetIt.java +++ b/core/src/test/java/com/github/dbunit/rules/EmptyDataSetIt.java @@ -4,7 +4,7 @@ import static com.github.dbunit.rules.util.EntityManagerProvider.tx; import static org.assertj.core.api.Assertions.assertThat; -import com.github.dbunit.rules.api.dbunit.DBUnitConfig; +import com.github.dbunit.rules.api.configuration.DBUnit; import org.junit.BeforeClass; import org.junit.Rule; import org.junit.Test; @@ -22,7 +22,7 @@ * Created by rmpestano on 8/21/16. */ @RunWith(JUnit4.class) -@DBUnitConfig(cacheConnection = true) +@DBUnit(cacheConnection = true) public class EmptyDataSetIt { EntityManagerProvider emProvider = EntityManagerProvider.instance("rules-it"); diff --git a/core/src/test/java/com/github/dbunit/rules/ExpectedDataSetIt.java b/core/src/test/java/com/github/dbunit/rules/ExpectedDataSetIt.java index 0696e54..ce6d4ea 100644 --- a/core/src/test/java/com/github/dbunit/rules/ExpectedDataSetIt.java +++ b/core/src/test/java/com/github/dbunit/rules/ExpectedDataSetIt.java @@ -2,18 +2,15 @@ import com.github.dbunit.rules.api.dataset.DataSet; import com.github.dbunit.rules.api.dataset.ExpectedDataSet; -import com.github.dbunit.rules.api.dbunit.DBUnitConfig; +import com.github.dbunit.rules.api.configuration.DBUnit; import com.github.dbunit.rules.model.User; import com.github.dbunit.rules.util.EntityManagerProvider; -import org.junit.Before; import org.junit.Ignore; import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; -import java.sql.SQLException; - import static com.github.dbunit.rules.util.EntityManagerProvider.em; import static com.github.dbunit.rules.util.EntityManagerProvider.tx; @@ -22,7 +19,7 @@ */ // tag::expectedDeclaration[] @RunWith(JUnit4.class) -@DBUnitConfig(cacheConnection = true) +@DBUnit(cacheConnection = true) public class ExpectedDataSetIt { @Rule diff --git a/core/src/test/java/com/github/dbunit/rules/MultipleExecutorsIt.java b/core/src/test/java/com/github/dbunit/rules/MultipleExecutorsIt.java index 2ba4ab3..131e6f1 100644 --- a/core/src/test/java/com/github/dbunit/rules/MultipleExecutorsIt.java +++ b/core/src/test/java/com/github/dbunit/rules/MultipleExecutorsIt.java @@ -19,7 +19,7 @@ import com.github.dbunit.rules.connection.ConnectionHolderImpl; import com.github.dbunit.rules.dataset.DataSetExecutorImpl; -import com.github.dbunit.rules.api.dataset.DataSetModel; +import com.github.dbunit.rules.configuration.DataSetConfig; import com.github.dbunit.rules.model.Follower; import com.github.dbunit.rules.model.User; @@ -54,8 +54,8 @@ public static void tearDown() throws SQLException { @Test public void shouldSeedDataSetDisablingContraints() { for (DataSetExecutorImpl executor : executors) { - DataSetModel dataSetModel = new DataSetModel("datasets/yml/users.yml").disableConstraints(true); - executor.createDataSet(dataSetModel); + DataSetConfig DataSetConfig = new DataSetConfig("datasets/yml/users.yml").disableConstraints(true); + executor.createDataSet(DataSetConfig); User user = (User) EntityManagerProvider.instance(executor.getId() + "-pu").em().createQuery("select u from User u where u.id = 1").getSingleResult(); assertThat(user).isNotNull(); assertThat(user.getId()).isEqualTo(1); @@ -66,8 +66,8 @@ public void shouldSeedDataSetDisablingContraints() { @Test public void shouldSeedDataSetDisablingContraintsViaStatement() { for (DataSetExecutorImpl executor : executors) { - DataSetModel dataSetModel = new DataSetModel("datasets/yml/users.yml").executeStatementsAfter(new String[]{"SET DATABASE REFERENTIAL INTEGRITY FALSE;"}); - executor.createDataSet(dataSetModel); + DataSetConfig DataSetConfig = new DataSetConfig("datasets/yml/users.yml").executeStatementsAfter(new String[]{"SET DATABASE REFERENTIAL INTEGRITY FALSE;"}); + executor.createDataSet(DataSetConfig); User user = (User) EntityManagerProvider.instance(executor.getId() + "-pu").em().createQuery("select u from User u where u.id = 1").getSingleResult(); assertThat(user).isNotNull(); assertThat(user.getId()).isEqualTo(1); @@ -79,11 +79,11 @@ public void shouldSeedDataSetDisablingContraintsViaStatement() { @Test public void shouldNotSeedDataSetWithoutSequenceFilter() { for (DataSetExecutorImpl executor : executors) { - DataSetModel dataSetModel = new DataSetModel("datasets/yml/users.yml"). + DataSetConfig DataSetConfig = new DataSetConfig("datasets/yml/users.yml"). useSequenceFiltering(false). executeStatementsAfter(new String[] { "DELETE FROM User" });//needed because other tests creates users and as the dataset is not created in this test the CLEAN is not performed try{ - executor.createDataSet(dataSetModel); + executor.createDataSet(DataSetConfig); }catch (DataBaseSeedingException e){ assertThat(e.getMessage()).isEqualTo("Could not initialize dataset: datasets/yml/users.yml"); } @@ -94,11 +94,11 @@ public void shouldNotSeedDataSetWithoutSequenceFilter() { @Test public void shouldSeedDataSetUsingTableCreationOrder() { for (DataSetExecutorImpl executor : executors) { - DataSetModel dataSetModel = new DataSetModel("datasets/yml/users.yml"). + DataSetConfig DataSetConfig = new DataSetConfig("datasets/yml/users.yml"). tableOrdering(new String[]{"USER","TWEET","FOLLOWER"}). executeStatementsBefore(new String[]{"DELETE FROM FOLLOWER","DELETE FROM TWEET","DELETE FROM USER"}).//needed because other tests created user dataset useSequenceFiltering(false); - executor.createDataSet(dataSetModel); + executor.createDataSet(DataSetConfig); List users = EntityManagerProvider.instance(executor.getId() + "-pu").em().createQuery("select u from User u").getResultList(); assertThat(users).hasSize(2); } @@ -108,9 +108,9 @@ public void shouldSeedDataSetUsingTableCreationOrder() { @Test public void shouldSeedUserDataSet() { for (DataSetExecutorImpl executor : executors) { - DataSetModel dataSetModel = new DataSetModel("datasets/yml/users.yml"). + DataSetConfig DataSetConfig = new DataSetConfig("datasets/yml/users.yml"). useSequenceFiltering(true); - executor.createDataSet(dataSetModel); + executor.createDataSet(DataSetConfig); User user = (User) EntityManagerProvider.instance(executor.getId() + "-pu").em().createQuery("select u from User u where u.id = 1").getSingleResult(); assertThat(user).isNotNull(); assertThat(user.getId()).isEqualTo(1); @@ -121,8 +121,8 @@ public void shouldSeedUserDataSet() { @Test public void shouldLoadUserFollowers() { for (DataSetExecutorImpl executor : executors) { - DataSetModel dataSetModel = new DataSetModel("datasets/yml/users.yml"); - executor.createDataSet(dataSetModel); + DataSetConfig DataSetConfig = new DataSetConfig("datasets/yml/users.yml"); + executor.createDataSet(DataSetConfig); User user = (User) EntityManagerProvider.newInstance(executor.getId() + "-pu").em().createQuery("select u from User u left join fetch u.followers where u.id = 1").getSingleResult(); assertThat(user).isNotNull(); assertThat(user.getId()).isEqualTo(1); @@ -138,8 +138,8 @@ public void shouldLoadUserFollowers() { @Test public void shouldLoadUsersFromJsonDataset() { for (DataSetExecutorImpl executor : executors) { - DataSetModel dataSetModel = new DataSetModel("datasets/json/users.json"); - executor.createDataSet(dataSetModel); + DataSetConfig DataSetConfig = new DataSetConfig("datasets/json/users.json"); + executor.createDataSet(DataSetConfig); User user = (User) EntityManagerProvider.newInstance(executor.getId() + "-pu").em().createQuery("select u from User u left join fetch u.followers where u.id = 1").getSingleResult(); assertThat(user).isNotNull(); assertThat(user.getId()).isEqualTo(1); @@ -155,8 +155,8 @@ public void shouldLoadUsersFromJsonDataset() { @Test public void shouldLoadUsersFromXmlDataset() { for (DataSetExecutorImpl executor : executors) { - DataSetModel dataSetModel = new DataSetModel("datasets/xml/users.xml"); - executor.createDataSet(dataSetModel); + DataSetConfig DataSetConfig = new DataSetConfig("datasets/xml/users.xml"); + executor.createDataSet(DataSetConfig); User user = (User) EntityManagerProvider.newInstance(executor.getId() + "-pu").em().createQuery("select u from User u left join fetch u.followers where u.id = 1").getSingleResult(); assertThat(user).isNotNull(); assertThat(user.getId()).isEqualTo(1); diff --git a/core/src/test/java/com/github/dbunit/rules/ScriptsIt.java b/core/src/test/java/com/github/dbunit/rules/ScriptsIt.java index 2699b07..7d30aa2 100644 --- a/core/src/test/java/com/github/dbunit/rules/ScriptsIt.java +++ b/core/src/test/java/com/github/dbunit/rules/ScriptsIt.java @@ -2,7 +2,7 @@ import com.github.dbunit.rules.api.dataset.DataSet; import com.github.dbunit.rules.api.dataset.SeedStrategy; -import com.github.dbunit.rules.api.dbunit.DBUnitConfig; +import com.github.dbunit.rules.api.configuration.DBUnit; import com.github.dbunit.rules.model.User; import com.github.dbunit.rules.util.EntityManagerProvider; import org.junit.AfterClass; @@ -23,7 +23,7 @@ * Created by pestano on 27/02/16. */ @RunWith(JUnit4.class) -@DBUnitConfig(cacheConnection = true) +@DBUnit(cacheConnection = true) public class ScriptsIt { @Rule diff --git a/core/src/test/java/com/github/dbunit/rules/TransactionIt.java b/core/src/test/java/com/github/dbunit/rules/TransactionIt.java index 0d3a8d5..1d00b5a 100644 --- a/core/src/test/java/com/github/dbunit/rules/TransactionIt.java +++ b/core/src/test/java/com/github/dbunit/rules/TransactionIt.java @@ -2,7 +2,7 @@ import com.github.dbunit.rules.api.dataset.DataSet; import com.github.dbunit.rules.api.dataset.ExpectedDataSet; -import com.github.dbunit.rules.api.dbunit.DBUnitConfig; +import com.github.dbunit.rules.api.configuration.DBUnit; import com.github.dbunit.rules.model.User; import com.github.dbunit.rules.util.EntityManagerProvider; import org.junit.Rule; @@ -18,7 +18,7 @@ */ @RunWith(JUnit4.class) -@DBUnitConfig(cacheConnection = true) +@DBUnit(cacheConnection = true) public class TransactionIt { @Rule diff --git a/core/src/test/java/com/github/dbunit/rules/configuration/ConfigurationTest.java b/core/src/test/java/com/github/dbunit/rules/configuration/ConfigurationTest.java new file mode 100644 index 0000000..4dae4ab --- /dev/null +++ b/core/src/test/java/com/github/dbunit/rules/configuration/ConfigurationTest.java @@ -0,0 +1,106 @@ +package com.github.dbunit.rules.configuration; + +import com.github.dbunit.rules.api.configuration.DBUnit; +import com.github.dbunit.rules.api.dataset.DataSet; +import com.github.dbunit.rules.api.dataset.SeedStrategy; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +import java.io.File; +import java.io.FileOutputStream; +import java.io.IOException; +import java.lang.reflect.Method; +import java.nio.file.Files; +import java.nio.file.Paths; + +import static org.assertj.core.api.Assertions.assertThat; + +/** + * Created by pestano on 03/09/16. + */ +@RunWith(JUnit4.class) +public class ConfigurationTest { + + + @Test + public void shouldLoadDBUnitConfigViaGlobalFile(){ + GlobaConfig globaConfig = GlobaConfig.newInstance(); + assertThat(globaConfig).isNotNull() + .extracting("dbUnitConfig.cacheConnection","dbUnitConfig.cacheTables") + .contains(false,false); + + assertThat(globaConfig.getDbUnitConfig().getProperties()). + containsEntry("allowEmptyFields", false). + containsEntry("batchedStatements", false). + containsEntry("qualifiedTableNames", false). + containsEntry("batchSize", 100). + containsEntry("fetchSize",100). + doesNotContainKey("escapePattern"); + } + + @Test + public void shouldLoadDBUnitConfigViaCustomGlobalFile() throws IOException { + File customConfig = new File("target/test-classes/dbunit.yml"); + FileOutputStream fos = new FileOutputStream(customConfig); + fos.write(Files.readAllBytes(Paths.get(getClass().getResource("/config/sample-dbunit.yml").getPath()))); + fos.flush(); + fos.close(); + + GlobaConfig globaConfig = GlobaConfig.newInstance(); + assertThat(globaConfig).isNotNull() + .extracting("dbUnitConfig.cacheConnection","dbUnitConfig.cacheTables") + .contains(true,true); + + assertThat(globaConfig.getDbUnitConfig().getProperties()). + containsEntry("allowEmptyFields", true). + containsEntry("batchedStatements", true). + containsEntry("qualifiedTableNames", true). + containsEntry("batchSize", 200). + containsEntry("fetchSize",200). + containsEntry("escapePattern","[?]"); + + customConfig.delete(); + } + + + + @Test + @DataSet(strategy = SeedStrategy.UPDATE,disableConstraints = true,cleanAfter = true,transactional = true) + public void shouldLoadDataSetConfigFromAnnotation() throws NoSuchMethodException { + Method method = getClass().getMethod("shouldLoadDataSetConfigFromAnnotation"); + assertThat(method).isNotNull(); + DataSet dataSet = method.getAnnotation(DataSet.class); + assertThat(dataSet).isNotNull(); + + DataSetConfig dataSetConfig = new DataSetConfig().from(dataSet); + assertThat(dataSetConfig).isNotNull(). + extracting("seedStrategy","useSequenceFiltering","disableConstraints","cleanBefore","cleanAfter","transactional"). + contains(SeedStrategy.UPDATE, true, true, false,true,true); + + } + + + @Test + @DBUnit(cacheConnection = true, cacheTableNames = false, allowEmptyFields = true,batchSize = 50) + public void shouldLoadDBUnitConfigViaAnnotation() throws NoSuchMethodException { + Method method = getClass().getMethod("shouldLoadDBUnitConfigViaAnnotation"); + assertThat(method).isNotNull(); + DBUnit dbUnit = method.getAnnotation(DBUnit.class); + assertThat(dbUnit).isNotNull(); + DBUnitConfig dbUnitConfig = DBUnitConfig.from(dbUnit); + assertThat(dbUnitConfig).isNotNull() + .extracting("cacheConnection","cacheTables") + .contains(true,false); + + assertThat(dbUnitConfig.getProperties()). + containsEntry("allowEmptyFields", true). + containsEntry("batchedStatements", false). + containsEntry("qualifiedTableNames", false). + containsEntry("batchSize", 50). + containsEntry("fetchSize",100). + doesNotContainKey("escapePattern"); + } + + +} diff --git a/core/src/test/resources/config/sample-dbunit.yml b/core/src/test/resources/config/sample-dbunit.yml new file mode 100644 index 0000000..b6c7975 --- /dev/null +++ b/core/src/test/resources/config/sample-dbunit.yml @@ -0,0 +1,10 @@ +dbUnitConfig: + cacheConnection: true + cacheTables: true + properties: + batchedStatements: true + qualifiedTableNames: true + batchSize: 200 + fetchSize: 200 + allowEmptyFields: true + escapePattern: "[?]" diff --git a/examples/dbunit-tomee-appcomposer-sample/src/test/java/com/github/dbunit/rules/example/UserRepositoryTest.java b/examples/dbunit-tomee-appcomposer-sample/src/test/java/com/github/dbunit/rules/example/UserRepositoryTest.java index 49675a0..aedce2a 100644 --- a/examples/dbunit-tomee-appcomposer-sample/src/test/java/com/github/dbunit/rules/example/UserRepositoryTest.java +++ b/examples/dbunit-tomee-appcomposer-sample/src/test/java/com/github/dbunit/rules/example/UserRepositoryTest.java @@ -32,14 +32,8 @@ public class UserRepositoryTest { @Rule public final TestRule rules = outerRule(new ApplicationComposerRule(this)) - .around(DBUnitRule.instance(() -> { - try { - return dataSource.getConnection(); - } catch (SQLException e) { - e.printStackTrace(); - return null; - } - })); + .around(DBUnitRule.instance(() -> dataSource.getConnection()) + ); @Inject diff --git a/examples/jOOQ-DBUnit-flyway-example/src/test/java/JooqDBUnitTest.java b/examples/jOOQ-DBUnit-flyway-example/src/test/java/JooqDBUnitTest.java index c2c6745..cfdfef4 100644 --- a/examples/jOOQ-DBUnit-flyway-example/src/test/java/JooqDBUnitTest.java +++ b/examples/jOOQ-DBUnit-flyway-example/src/test/java/JooqDBUnitTest.java @@ -1,9 +1,8 @@ import com.github.dbunit.rules.DBUnitRule; import com.github.dbunit.rules.api.dataset.DataSet; import com.github.dbunit.rules.api.dataset.ExpectedDataSet; -import com.github.dbunit.rules.api.dbunit.DBUnitConfig; +import com.github.dbunit.rules.api.configuration.DBUnit; -import org.dbunit.database.DatabaseConfig; import org.flywaydb.core.Flyway; import org.jooq.DSLContext; import org.jooq.Result; @@ -25,7 +24,7 @@ /** * Created by Lukas on 23.06.2014. */ -@DBUnitConfig(qualifiedTableNames = true) +@DBUnit(qualifiedTableNames = true) public class JooqDBUnitTest { private static String DB_URL = "jdbc:h2:" + Paths.get("target").toAbsolutePath().toString() + diff --git a/examples/jpa-productivity-boosters/src/test/java/com/github/dbunit/rules/examples/cucumber/withoutcdi/ContactStepsWithoutCDI.java b/examples/jpa-productivity-boosters/src/test/java/com/github/dbunit/rules/examples/cucumber/withoutcdi/ContactStepsWithoutCDI.java index 891ff4e..ea024ba 100644 --- a/examples/jpa-productivity-boosters/src/test/java/com/github/dbunit/rules/examples/cucumber/withoutcdi/ContactStepsWithoutCDI.java +++ b/examples/jpa-productivity-boosters/src/test/java/com/github/dbunit/rules/examples/cucumber/withoutcdi/ContactStepsWithoutCDI.java @@ -1,7 +1,7 @@ package com.github.dbunit.rules.examples.cucumber.withoutcdi; import com.github.dbunit.rules.api.dataset.DataSetExecutor; -import com.github.dbunit.rules.api.dataset.DataSetModel; +import com.github.dbunit.rules.configuration.DataSetConfig; import com.github.dbunit.rules.connection.ConnectionHolderImpl; import com.github.dbunit.rules.dataset.DataSetExecutorImpl; import com.github.dbunit.rules.util.EntityManagerProvider; @@ -37,7 +37,7 @@ public void setUp() { @Given("^we have a list of contacts2$") public void given() { - dbunitExecutor.createDataSet(new DataSetModel("contacts.yml")); + dbunitExecutor.createDataSet(new DataSetConfig("contacts.yml")); assertEquals(em().createQuery("select count(c.id) from Contact c").getSingleResult(), new Long(3)); } diff --git a/junit5/src/main/java/com/github/dbunit/junit5/DBUnitExtension.java b/junit5/src/main/java/com/github/dbunit/junit5/DBUnitExtension.java index 453cb62..76d9f58 100644 --- a/junit5/src/main/java/com/github/dbunit/junit5/DBUnitExtension.java +++ b/junit5/src/main/java/com/github/dbunit/junit5/DBUnitExtension.java @@ -1,10 +1,13 @@ package com.github.dbunit.junit5; +import com.github.dbunit.rules.api.configuration.DBUnit; import com.github.dbunit.rules.api.connection.ConnectionHolder; import com.github.dbunit.rules.api.dataset.DataSet; import com.github.dbunit.rules.api.dataset.DataSetExecutor; -import com.github.dbunit.rules.api.dataset.DataSetModel; import com.github.dbunit.rules.api.dataset.ExpectedDataSet; +import com.github.dbunit.rules.configuration.DBUnitConfig; +import com.github.dbunit.rules.configuration.DataSetConfig; +import com.github.dbunit.rules.configuration.GlobaConfig; import com.github.dbunit.rules.dataset.DataSetExecutorImpl; import org.junit.jupiter.api.extension.AfterTestExecutionCallback; import org.junit.jupiter.api.extension.BeforeTestExecutionCallback; @@ -48,24 +51,41 @@ public void beforeTestExecution(TestExtensionContext testExtensionContext) throw throw new RuntimeException("Could not find DataSet annotation for test " + testExtensionContext.getTestMethod().get().getName()); } - final DataSetModel model = new DataSetModel().from(annotation); - DataSetExecutor executor = DataSetExecutorImpl.instance(model.getExecutorId(), connectionHolder); + final DataSetConfig dasetConfig = new DataSetConfig().from(annotation); + DataSetExecutor executor = DataSetExecutorImpl.instance(dasetConfig.getExecutorId(), connectionHolder); + executor.setDbUnitConfig(resolveDBUnitConfig(testExtensionContext)); + ExtensionContext.Namespace namespace = getExecutorNamespace(testExtensionContext);//one executor per test class testExtensionContext.getStore(namespace).put("executor", executor); - testExtensionContext.getStore(namespace).put("model", model); + testExtensionContext.getStore(namespace).put("model", dasetConfig); + + try { - executor.createDataSet(model); + executor.createDataSet(dasetConfig); } catch (final Exception e) { throw new RuntimeException(String.format("Could not create dataset for test method %s due to following error " + e.getMessage(), testExtensionContext.getTestMethod().get().getName()), e); } - boolean isTransactional = model.isTransactional() && isEntityManagerActive(); + boolean isTransactional = dasetConfig.isTransactional() && isEntityManagerActive(); if (isTransactional) { em().getTransaction().begin(); } } + private DBUnitConfig resolveDBUnitConfig(TestExtensionContext testExtensionContext) { + DBUnit dbUnitConfig = testExtensionContext.getTestMethod().get().getAnnotation(DBUnit.class); + if (dbUnitConfig == null) { + dbUnitConfig = testExtensionContext.getTestClass().get().getAnnotation(DBUnit.class); + } + + if (dbUnitConfig != null) { + return DBUnitConfig.from(dbUnitConfig); + } else { + return GlobaConfig.instance().getDbUnitConfig(); + } + } + private boolean shouldCreateDataSet(TestExtensionContext testExtensionContext) { return testExtensionContext.getTestMethod().get().isAnnotationPresent(DataSet.class) || testExtensionContext.getTestClass().get().isAnnotationPresent(DataSet.class); } @@ -87,12 +107,12 @@ public void afterTestExecution(TestExtensionContext testExtensionContext) throws if (expectedDataSet != null) { ExtensionContext.Namespace namespace = getExecutorNamespace(testExtensionContext);//one executor per test class DataSetExecutor executor = testExtensionContext.getStore(namespace).get("executor", DataSetExecutor.class); - DataSetModel model = testExtensionContext.getStore(namespace).get("model", DataSetModel.class); - boolean isTransactional = model.isTransactional() && isEntityManagerActive(); + DataSetConfig datasetConfig = testExtensionContext.getStore(namespace).get("model", DataSetConfig.class); + boolean isTransactional = datasetConfig.isTransactional() && isEntityManagerActive(); if (isTransactional) { em().getTransaction().commit(); } - executor.compareCurrentDataSetWith(new DataSetModel(expectedDataSet.value()).disableConstraints(true), expectedDataSet.ignoreCols()); + executor.compareCurrentDataSetWith(new DataSetConfig(expectedDataSet.value()).disableConstraints(true), expectedDataSet.ignoreCols()); } } diff --git a/pom.xml b/pom.xml index ccbd401..738a868 100644 --- a/pom.xml +++ b/pom.xml @@ -92,7 +92,7 @@ org.assertj assertj-core - 2.1.0 + 2.5.0 test