From 9cd5db43704aa53e2464f7b1fae108cb02079c8c Mon Sep 17 00:00:00 2001 From: rmpestano Date: Mon, 29 Aug 2016 19:11:27 -0300 Subject: [PATCH] fixes #39 --- .../com/github/dbunit/rules/DBUnitRule.java | 5 + .../rules/api/dataset/DataSetExecutor.java | 86 +++-- .../rules/api/dataset/DataSetModel.java | 364 +++++++++--------- .../rules/dataset/DataSetExecutorImpl.java | 26 +- .../github/dbunit/rules/DBUnitRulesIt.java | 308 +++++++-------- .../github/dbunit/rules/EmptyDataSetIt.java | 208 +++++----- .../github/dbunit/rules/TransactionIt.java | 2 +- 7 files changed, 513 insertions(+), 486 deletions(-) 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 03d1010..c22a696 100644 --- a/core/src/main/java/com/github/dbunit/rules/DBUnitRule.java +++ b/core/src/main/java/com/github/dbunit/rules/DBUnitRule.java @@ -156,5 +156,10 @@ public DataSetExecutor getDataSetExecutor() { return executor; } + public DBUnitRule cacheConnection(boolean cacheConnection) { + executor.cacheConnection(cacheConnection); + return this; + } + } \ No newline at end of file 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 f62a41b..3139a3a 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,40 +1,46 @@ -package com.github.dbunit.rules.api.dataset; - -import com.github.dbunit.rules.api.connection.ConnectionHolder; -import org.dbunit.DatabaseUnitException; -import org.dbunit.dataset.DataSetException; -import org.dbunit.dataset.IDataSet; - -import java.io.IOException; -import java.sql.SQLException; - -/** - * Created by pestano on 01/08/15. - */ -public interface DataSetExecutor{ - - /** - * creates a dataset into executor's database connection using given dataSetModel - * @param dataSetModel - */ - void createDataSet(DataSetModel dataSetModel); - - IDataSet loadDataSet(String name) throws DataSetException, IOException; - - ConnectionHolder getConnectionHolder(); - - void clearDatabase(DataSetModel dataset) throws SQLException; - - void executeStatements(String[] statements); - - void executeScript(String scriptPath); - - String getId(); - - /** - * compares dataset from executor's databse connection with a given dataset - * @param expected - * @throws DatabaseUnitException if current dataset is not equal current dataset - */ - void compareCurrentDataSetWith(DataSetModel expected, String[] ignoreCols) throws DatabaseUnitException; -} +package com.github.dbunit.rules.api.dataset; + +import com.github.dbunit.rules.api.connection.ConnectionHolder; +import org.dbunit.DatabaseUnitException; +import org.dbunit.dataset.DataSetException; +import org.dbunit.dataset.IDataSet; + +import java.io.IOException; +import java.sql.SQLException; + +/** + * Created by pestano on 01/08/15. + */ +public interface DataSetExecutor{ + + /** + * creates a dataset into executor's database connection using given dataSetModel + * @param dataSetModel + */ + void createDataSet(DataSetModel dataSetModel); + + IDataSet loadDataSet(String name) throws DataSetException, IOException; + + ConnectionHolder getConnectionHolder(); + + void clearDatabase(DataSetModel dataset) throws SQLException; + + void executeStatements(String[] statements); + + void executeScript(String scriptPath); + + String getId(); + + /** + * compares dataset from executor's databse connection with a given dataset + * @param expected + * @throws DatabaseUnitException if current dataset is not equal current dataset + */ + void compareCurrentDataSetWith(DataSetModel expected, String[] ignoreCols) throws DatabaseUnitException; + + + /** + * @param cacheConnection if true database connection will be reused among multiple executions of same executor. + */ + DataSetExecutor cacheConnection(boolean cacheConnection); +} diff --git a/core/src/main/java/com/github/dbunit/rules/api/dataset/DataSetModel.java b/core/src/main/java/com/github/dbunit/rules/api/dataset/DataSetModel.java index 40a90a1..220a02d 100644 --- a/core/src/main/java/com/github/dbunit/rules/api/dataset/DataSetModel.java +++ b/core/src/main/java/com/github/dbunit/rules/api/dataset/DataSetModel.java @@ -1,182 +1,182 @@ -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.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; + } +} 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 c6f6b67..019fbdb 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 @@ -50,7 +50,9 @@ public class DataSetExecutorImpl implements DataSetExecutor { public static final String DEFAULT_EXECUTOR_ID = "default"; - + + private static String SEQUENCE_TABLE_NAME; + private static Map executors = new ConcurrentHashMap<>(); private DatabaseConnection databaseConnection; @@ -58,8 +60,14 @@ public class DataSetExecutorImpl implements DataSetExecutor { private ConnectionHolder connectionHolder; private String id; + + private boolean cacheConnection = false; private static final Logger log = LoggerFactory.getLogger(DataSetExecutorImpl.class); + + static { + SEQUENCE_TABLE_NAME = System.getProperty("SEQUENCE_TABLE_NAME") == null ? "SEQ" : System.getProperty("SEQUENCE_TABLE_NAME"); + } public static DataSetExecutorImpl instance(ConnectionHolder connectionHolder) { @@ -98,7 +106,9 @@ public void createDataSet(DataSetModel dataSetModel) { if (dataSetModel != null) { try { - initDatabaseConnection(); + if(databaseConnection == null || !cacheConnection){ + initDatabaseConnection(); + } if (dataSetModel.isDisableConstraints()) { disableConstraints(); } @@ -317,8 +327,8 @@ private IDataSet performReplacements(IDataSet dataSet) { private void initDatabaseConnection() throws DatabaseUnitException, SQLException { - databaseConnection = new DatabaseConnection(connectionHolder.getConnection()); - configDatabaseProperties(); + databaseConnection = new DatabaseConnection(connectionHolder.getConnection()); + configDatabaseProperties(); } @@ -390,7 +400,7 @@ public void clearDatabase(DataSetModel dataset) throws SQLException { if (dataset != null && dataset.getTableOrdering() != null && dataset.getTableOrdering().length > 0) { for (String table : dataset.getTableOrdering()) { - if (table.toUpperCase().contains("SEQ")) { + if (table.toUpperCase().contains(SEQUENCE_TABLE_NAME)) { //tables containing 'SEQ'will NOT be cleared see https://github.com/rmpestano/dbunit-rules/issues/26 continue; } @@ -543,4 +553,10 @@ public void compareCurrentDataSetWith(DataSetModel expectedDataSetModel, String[ } + @Override + public DataSetExecutor cacheConnection(boolean cacheConnection) { + this.cacheConnection = cacheConnection; + return this; + } + } 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 24ee229..f2fa844 100644 --- a/core/src/test/java/com/github/dbunit/rules/DBUnitRulesIt.java +++ b/core/src/test/java/com/github/dbunit/rules/DBUnitRulesIt.java @@ -1,154 +1,154 @@ -package com.github.dbunit.rules; - -import com.github.dbunit.rules.api.dataset.DataSet; -import com.github.dbunit.rules.api.dataset.SeedStrategy; -import com.github.dbunit.rules.dataset.DataSetExecutorImpl; -import com.github.dbunit.rules.model.Follower; -import com.github.dbunit.rules.model.Tweet; -import com.github.dbunit.rules.model.User; -import com.github.dbunit.rules.util.EntityManagerProvider; -import org.junit.AfterClass; -import org.junit.Rule; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.JUnit4; - -import java.sql.SQLException; -import java.util.Calendar; -import java.util.List; - -import static com.github.dbunit.rules.util.EntityManagerProvider.em; -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.Assert.assertEquals; - -/** - * Created by pestano on 23/07/15. - */ - - -@RunWith(JUnit4.class) -public class DBUnitRulesIt { - - // tag::rules[] - @Rule - public EntityManagerProvider emProvider = EntityManagerProvider.instance("rules-it"); //<1> - - @Rule - public DBUnitRule dbUnitRule = DBUnitRule.instance(emProvider.connection()); //<2> - // end::rules[] - - @Test - @DataSet(value = "datasets/yml/users.yml",disableConstraints = true) - public void shouldSeedDataSetDisablingContraints() { - User user = (User) em().createQuery("select u from User u where u.id = 1").getSingleResult(); - assertThat(user).isNotNull(); - assertThat(user.getId()).isEqualTo(1); - } - - @Test - @DataSet(value = "datasets/yml/user.yml") - public void shouldSeedDatabase() { - List users = em().createQuery("select u from User u ").getResultList(); - assertThat(users). - isNotNull(). - isNotEmpty(). - hasSize(2); - } - - @Test - @DataSet(value = "datasets/yml/users.yml", executeStatementsBefore = "SET DATABASE REFERENTIAL INTEGRITY FALSE;") - public void shouldSeedDataSetDisablingContraintsViaStatement() { - User user = (User) em().createQuery("select u from User u join fetch u.tweets join fetch u.followers join fetch u.tweets join fetch u.followers where u.id = 1").getSingleResult(); - assertThat(user).isNotNull(); - assertThat(user.getId()).isEqualTo(1); - assertThat(user.getTweets()).hasSize(1); - } - - - - @Test - @DataSet(value = "datasets/yml/users.yml", - useSequenceFiltering = false, - tableOrdering = {"USER","TWEET","FOLLOWER"}, - executeStatementsBefore = {"DELETE FROM FOLLOWER","DELETE FROM TWEET","DELETE FROM USER"}//needed because other tests created user dataset - ) - public void shouldSeedDataSetUsingTableCreationOrder() { - List users = em().createQuery("select u from User u left join fetch u.tweets left join fetch u.followers").getResultList(); - assertThat(users).hasSize(2); - } - - - // tag::seedDatabase[] - @Test - @DataSet(value = "datasets/yml/users.yml", useSequenceFiltering = true) - public void shouldSeedUserDataSet() { - User user = (User) em().createQuery("select u from User u join fetch u.tweets join fetch u.followers where u.id = 1").getSingleResult(); - assertThat(user).isNotNull(); - assertThat(user.getId()).isEqualTo(1); - assertThat(user.getTweets()).isNotNull().hasSize(1); - Tweet tweet = user.getTweets().get(0); - assertThat(tweet).isNotNull(); - Calendar date = tweet.getDate(); - Calendar now = Calendar.getInstance(); - assertThat(date.get(Calendar.DAY_OF_MONTH)).isEqualTo(now.get(Calendar.DAY_OF_MONTH)); - } - // end::seedDatabase[] - - @Test - @DataSet(value = "datasets/yml/users.yml") - public void shouldLoadUserFollowers() { - User user = (User) em().createQuery("select u from User u join fetch u.tweets join fetch u.followers left join fetch u.followers where u.id = 1").getSingleResult(); - assertThat(user).isNotNull(); - assertThat(user.getId()).isEqualTo(1); - assertThat(user.getTweets()).hasSize(1); - assertEquals(user.getTweets().get(0).getContent(), "dbunit rules!"); - assertThat(user.getFollowers()).isNotNull().hasSize(1); - Follower expectedFollower = new Follower(2,1); - assertThat(user.getFollowers()).contains(expectedFollower); - } - - @Test - @DataSet(value = "datasets/json/users.json") - public void shouldLoadUsersFromJsonDataset() { - User user = (User) em().createQuery("select u from User u join fetch u.tweets join fetch u.followers left join fetch u.followers where u.id = 1").getSingleResult(); - assertThat(user).isNotNull(); - assertThat(user.getId()).isEqualTo(1); - assertThat(user.getTweets()).hasSize(1); - assertEquals("dbunit rules json example",user.getTweets().get(0).getContent()); - assertThat(user.getFollowers()).isNotNull().hasSize(1); - Follower expectedFollower = new Follower(2,1); - assertThat(user.getFollowers()).contains(expectedFollower); - } - - @Test - @DataSet(value = "datasets/xml/users.xml") - public void shouldLoadUsersFromXmlDataset() { - User user = (User) em().createQuery("select u from User u join fetch u.tweets join fetch u.followers left join fetch u.followers where u.id = 1").getSingleResult(); - assertThat(user).isNotNull(); - assertThat(user.getId()).isEqualTo(1); - assertThat(user.getTweets()).hasSize(1); - assertEquals("dbunit rules flat xml example",user.getTweets().get(0).getContent()); - assertThat(user.getFollowers()).isNotNull().hasSize(1); - Follower expectedFollower = new Follower(2,1); - assertThat(user.getFollowers()).contains(expectedFollower); - } - - @Test - @DataSet(strategy = SeedStrategy.INSERT, value = "yml/user.yml, yml/tweet.yml, yml/follower.yml", executeStatementsBefore = {"DELETE FROM FOLLOWER","DELETE FROM TWEET","DELETE FROM USER"}) - public void shouldLoadDataFromMultipleDataSets(){ - User user = (User) em("rules-it").createQuery("select u from User u join fetch u.tweets join fetch u.followers left join fetch u.followers where u.id = 1").getSingleResult(); - assertThat(user).isNotNull(); - assertThat(user.getId()).isEqualTo(1); - assertThat(user.getTweets()).hasSize(1); - assertEquals("dbunit rules again!",user.getTweets().get(0).getContent()); - assertThat(user.getFollowers()).isNotNull().hasSize(1); - Follower expectedFollower = new Follower(2,1); - assertThat(user.getFollowers()).contains(expectedFollower); - } - - @AfterClass//optional - public static void close() throws SQLException { - DataSetExecutorImpl.getExecutorById(DataSetExecutorImpl.DEFAULT_EXECUTOR_ID).getConnection().close(); - } - -} +package com.github.dbunit.rules; + +import com.github.dbunit.rules.api.dataset.DataSet; +import com.github.dbunit.rules.api.dataset.SeedStrategy; +import com.github.dbunit.rules.dataset.DataSetExecutorImpl; +import com.github.dbunit.rules.model.Follower; +import com.github.dbunit.rules.model.Tweet; +import com.github.dbunit.rules.model.User; +import com.github.dbunit.rules.util.EntityManagerProvider; +import org.junit.AfterClass; +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +import java.sql.SQLException; +import java.util.Calendar; +import java.util.List; + +import static com.github.dbunit.rules.util.EntityManagerProvider.em; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.assertEquals; + +/** + * Created by pestano on 23/07/15. + */ + + +@RunWith(JUnit4.class) +public class DBUnitRulesIt { + + // tag::rules[] + @Rule + public EntityManagerProvider emProvider = EntityManagerProvider.instance("rules-it"); //<1> + + @Rule + public DBUnitRule dbUnitRule = DBUnitRule.instance(emProvider.connection()).cacheConnection(true); //<2> + // end::rules[] + + @Test + @DataSet(value = "datasets/yml/users.yml",disableConstraints = true) + public void shouldSeedDataSetDisablingContraints() { + User user = (User) em().createQuery("select u from User u where u.id = 1").getSingleResult(); + assertThat(user).isNotNull(); + assertThat(user.getId()).isEqualTo(1); + } + + @Test + @DataSet(value = "datasets/yml/user.yml") + public void shouldSeedDatabase() { + List users = em().createQuery("select u from User u ").getResultList(); + assertThat(users). + isNotNull(). + isNotEmpty(). + hasSize(2); + } + + @Test + @DataSet(value = "datasets/yml/users.yml", executeStatementsBefore = "SET DATABASE REFERENTIAL INTEGRITY FALSE;") + public void shouldSeedDataSetDisablingContraintsViaStatement() { + User user = (User) em().createQuery("select u from User u join fetch u.tweets join fetch u.followers join fetch u.tweets join fetch u.followers where u.id = 1").getSingleResult(); + assertThat(user).isNotNull(); + assertThat(user.getId()).isEqualTo(1); + assertThat(user.getTweets()).hasSize(1); + } + + + + @Test + @DataSet(value = "datasets/yml/users.yml", + useSequenceFiltering = false, + tableOrdering = {"USER","TWEET","FOLLOWER"}, + executeStatementsBefore = {"DELETE FROM FOLLOWER","DELETE FROM TWEET","DELETE FROM USER"}//needed because other tests created user dataset + ) + public void shouldSeedDataSetUsingTableCreationOrder() { + List users = em().createQuery("select u from User u left join fetch u.tweets left join fetch u.followers").getResultList(); + assertThat(users).hasSize(2); + } + + + // tag::seedDatabase[] + @Test + @DataSet(value = "datasets/yml/users.yml", useSequenceFiltering = true) + public void shouldSeedUserDataSet() { + User user = (User) em().createQuery("select u from User u join fetch u.tweets join fetch u.followers where u.id = 1").getSingleResult(); + assertThat(user).isNotNull(); + assertThat(user.getId()).isEqualTo(1); + assertThat(user.getTweets()).isNotNull().hasSize(1); + Tweet tweet = user.getTweets().get(0); + assertThat(tweet).isNotNull(); + Calendar date = tweet.getDate(); + Calendar now = Calendar.getInstance(); + assertThat(date.get(Calendar.DAY_OF_MONTH)).isEqualTo(now.get(Calendar.DAY_OF_MONTH)); + } + // end::seedDatabase[] + + @Test + @DataSet(value = "datasets/yml/users.yml") + public void shouldLoadUserFollowers() { + User user = (User) em().createQuery("select u from User u join fetch u.tweets join fetch u.followers left join fetch u.followers where u.id = 1").getSingleResult(); + assertThat(user).isNotNull(); + assertThat(user.getId()).isEqualTo(1); + assertThat(user.getTweets()).hasSize(1); + assertEquals(user.getTweets().get(0).getContent(), "dbunit rules!"); + assertThat(user.getFollowers()).isNotNull().hasSize(1); + Follower expectedFollower = new Follower(2,1); + assertThat(user.getFollowers()).contains(expectedFollower); + } + + @Test + @DataSet(value = "datasets/json/users.json") + public void shouldLoadUsersFromJsonDataset() { + User user = (User) em().createQuery("select u from User u join fetch u.tweets join fetch u.followers left join fetch u.followers where u.id = 1").getSingleResult(); + assertThat(user).isNotNull(); + assertThat(user.getId()).isEqualTo(1); + assertThat(user.getTweets()).hasSize(1); + assertEquals("dbunit rules json example",user.getTweets().get(0).getContent()); + assertThat(user.getFollowers()).isNotNull().hasSize(1); + Follower expectedFollower = new Follower(2,1); + assertThat(user.getFollowers()).contains(expectedFollower); + } + + @Test + @DataSet(value = "datasets/xml/users.xml") + public void shouldLoadUsersFromXmlDataset() { + User user = (User) em().createQuery("select u from User u join fetch u.tweets join fetch u.followers left join fetch u.followers where u.id = 1").getSingleResult(); + assertThat(user).isNotNull(); + assertThat(user.getId()).isEqualTo(1); + assertThat(user.getTweets()).hasSize(1); + assertEquals("dbunit rules flat xml example",user.getTweets().get(0).getContent()); + assertThat(user.getFollowers()).isNotNull().hasSize(1); + Follower expectedFollower = new Follower(2,1); + assertThat(user.getFollowers()).contains(expectedFollower); + } + + @Test + @DataSet(strategy = SeedStrategy.INSERT, value = "yml/user.yml, yml/tweet.yml, yml/follower.yml", executeStatementsBefore = {"DELETE FROM FOLLOWER","DELETE FROM TWEET","DELETE FROM USER"}) + public void shouldLoadDataFromMultipleDataSets(){ + User user = (User) em("rules-it").createQuery("select u from User u join fetch u.tweets join fetch u.followers left join fetch u.followers where u.id = 1").getSingleResult(); + assertThat(user).isNotNull(); + assertThat(user.getId()).isEqualTo(1); + assertThat(user.getTweets()).hasSize(1); + assertEquals("dbunit rules again!",user.getTweets().get(0).getContent()); + assertThat(user.getFollowers()).isNotNull().hasSize(1); + Follower expectedFollower = new Follower(2,1); + assertThat(user.getFollowers()).contains(expectedFollower); + } + + @AfterClass//optional + public static void close() throws SQLException { + DataSetExecutorImpl.getExecutorById(DataSetExecutorImpl.DEFAULT_EXECUTOR_ID).getConnection().close(); + } + +} 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 8ad566a..4f0167b 100644 --- a/core/src/test/java/com/github/dbunit/rules/EmptyDataSetIt.java +++ b/core/src/test/java/com/github/dbunit/rules/EmptyDataSetIt.java @@ -1,104 +1,104 @@ -package com.github.dbunit.rules; - -import com.github.dbunit.rules.api.dataset.DataSet; -import com.github.dbunit.rules.api.dataset.ExpectedDataSet; -import com.github.dbunit.rules.model.User; -import com.github.dbunit.rules.util.EntityManagerProvider; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.RuleChain; -import org.junit.rules.TestRule; -import org.junit.runner.RunWith; -import org.junit.runners.JUnit4; - -import static com.github.dbunit.rules.util.EntityManagerProvider.em; -import static com.github.dbunit.rules.util.EntityManagerProvider.tx; -import static org.assertj.core.api.Assertions.assertThat; - -/** - * Created by rmpestano on 8/21/16. - */ -@RunWith(JUnit4.class) -public class EmptyDataSetIt { - - EntityManagerProvider emProvider = EntityManagerProvider.instance("rules-it"); - - @Rule - public TestRule theRule = RuleChain.outerRule(emProvider). - around(DBUnitRule.instance(emProvider.connection())); - - - @BeforeClass - public static void init(){ - User user = new User(); - user.setName("user"); - user.setName("@rmpestano"); - tx("rules-it").begin(); - em("rules-it").persist(user); - tx("rules-it").commit(); - } - - @Test - @DataSet(value = "yml/empty.yml") - public void shouldSeedDatabaseWithEmptyDataSet() { - long count = (long) em().createQuery("select count(u.id) from User u").getSingleResult(); - assertThat(0L).isEqualTo(count); - User user = new User(); - user.setName("user"); - user.setName("@rmpestano"); - tx().begin(); - em().persist(user); - tx().commit(); - User insertedUser = (User)em().createQuery("select u from User u where u.name = '@rmpestano'").getSingleResult(); - assertThat(insertedUser).isNotNull(); - assertThat(insertedUser.getId()).isNotNull(); - } - - @Test - @DataSet("yml/empty.yml") - @ExpectedDataSet("yml/empty.yml") - public void shouldSeedAndExpectEmptyDataSet() { - } - - @Test - @DataSet(value = "yml/user.yml", disableConstraints = true) - @ExpectedDataSet(value = "yml/empty.yml") - public void shouldMatchEmptyYmlDataSet() { - tx().begin(); - em().remove(em().find(User.class,1L)); - em().remove(em().find(User.class,2L)); - tx().commit(); - } - - @Test - @DataSet(value = "yml/user.yml", disableConstraints = true, transactional = true) - @ExpectedDataSet(value = "yml/empty.yml") - public void shouldMatchEmptyYmlDataSetWithTransaction() { - em().remove(em().find(User.class,1L)); - em().remove(em().find(User.class,2L)); - } - - - @Test - @DataSet(value = "json/user.json", disableConstraints = true) - @ExpectedDataSet(value = "json/empty.json") - public void shouldMatchEmptyJsonDataSet() { - tx().begin(); - em().remove(em().find(User.class,1L)); - em().remove(em().find(User.class,2L)); - tx().commit(); - em().createQuery("select u from User u").getResultList(); - } - - @Test - @DataSet(value = "xml/user.xml", disableConstraints = true) - @ExpectedDataSet(value = "xml/empty.xml") - public void shouldMatchEmptyXmlDataSet() { - tx().begin(); - em().remove(em().find(User.class,1L)); - em().remove(em().find(User.class,2L)); - tx().commit(); - } -} +package com.github.dbunit.rules; + +import static com.github.dbunit.rules.util.EntityManagerProvider.em; +import static com.github.dbunit.rules.util.EntityManagerProvider.tx; +import static org.assertj.core.api.Assertions.assertThat; + +import org.junit.BeforeClass; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.RuleChain; +import org.junit.rules.TestRule; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +import com.github.dbunit.rules.api.dataset.DataSet; +import com.github.dbunit.rules.api.dataset.ExpectedDataSet; +import com.github.dbunit.rules.model.User; +import com.github.dbunit.rules.util.EntityManagerProvider; + +/** + * Created by rmpestano on 8/21/16. + */ +@RunWith(JUnit4.class) +public class EmptyDataSetIt { + + EntityManagerProvider emProvider = EntityManagerProvider.instance("rules-it"); + + @Rule + public TestRule theRule = RuleChain.outerRule(emProvider). + around(DBUnitRule.instance(emProvider.connection()).cacheConnection(true)); + + + @BeforeClass + public static void init(){ + User user = new User(); + user.setName("user"); + user.setName("@rmpestano"); + tx("rules-it").begin(); + em("rules-it").persist(user); + tx("rules-it").commit(); + } + + @Test + @DataSet(value = "yml/empty.yml") + public void shouldSeedDatabaseWithEmptyDataSet() { + long count = (long) em().createQuery("select count(u.id) from User u").getSingleResult(); + assertThat(0L).isEqualTo(count); + User user = new User(); + user.setName("user"); + user.setName("@rmpestano"); + tx().begin(); + em().persist(user); + tx().commit(); + User insertedUser = (User)em().createQuery("select u from User u where u.name = '@rmpestano'").getSingleResult(); + assertThat(insertedUser).isNotNull(); + assertThat(insertedUser.getId()).isNotNull(); + } + + @Test + @DataSet("yml/empty.yml") + @ExpectedDataSet("yml/empty.yml") + public void shouldSeedAndExpectEmptyDataSet() { + } + + @Test + @DataSet(value = "yml/user.yml", disableConstraints = true) + @ExpectedDataSet(value = "yml/empty.yml") + public void shouldMatchEmptyYmlDataSet() { + tx().begin(); + em().remove(em().find(User.class,1L)); + em().remove(em().find(User.class,2L)); + tx().commit(); + } + + @Test + @DataSet(value = "yml/user.yml", disableConstraints = true, transactional = true) + @ExpectedDataSet(value = "yml/empty.yml") + public void shouldMatchEmptyYmlDataSetWithTransaction() { + em().remove(em().find(User.class,1L)); + em().remove(em().find(User.class,2L)); + } + + + @Test + @DataSet(value = "json/user.json", disableConstraints = true) + @ExpectedDataSet(value = "json/empty.json") + public void shouldMatchEmptyJsonDataSet() { + tx().begin(); + em().remove(em().find(User.class,1L)); + em().remove(em().find(User.class,2L)); + tx().commit(); + em().createQuery("select u from User u").getResultList(); + } + + @Test + @DataSet(value = "xml/user.xml", disableConstraints = true) + @ExpectedDataSet(value = "xml/empty.xml") + public void shouldMatchEmptyXmlDataSet() { + tx().begin(); + em().remove(em().find(User.class,1L)); + em().remove(em().find(User.class,2L)); + tx().commit(); + } +} 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 e7867a2..f36c5ff 100644 --- a/core/src/test/java/com/github/dbunit/rules/TransactionIt.java +++ b/core/src/test/java/com/github/dbunit/rules/TransactionIt.java @@ -23,7 +23,7 @@ public class TransactionIt { public EntityManagerProvider emProvider = EntityManagerProvider.instance("rules-it"); @Rule - public DBUnitRule dbUnitRule = DBUnitRule.instance(emProvider.connection()); + public DBUnitRule dbUnitRule = DBUnitRule.instance(TransactionIt.class.getName(),emProvider.connection()); @Test @DataSet(cleanBefore = true)