Problemas usando dbunit com primavera testcontext
-
27-09-2019 - |
Pergunta
Estou tentando testar minha camada DAO (que é construída no JPA) em separação. No teste de unidade, estou usando o DBunit para preencher o banco de dados e o teste de mola para obter uma instância do ApplicationContext.
Quando tentei usar o springjunit4classRuner, o ApplicationContext foi injetado, mas o método getDataSet () do dbunit nunca foi chamado.
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "/testdao.xml")
public class SimpleJPATest extends DBTestCase implements ApplicationContextAware {
...
Então tentei remover o @Runwith Anotation, que removeu os problemas com o método getDataset (). Mas agora não tenho mais a instância do ApplicationContext injetada. Tentei usar a anotação @TestExecutionListenners, que deve configurar o dependeNjectionTestExecutionListener por padrão, mas o AppContext ainda não é injetado.
@TestExecutionListeners
@ContextConfiguration(locations = "/testdao.xml")
public class SimpleJPATest extends DBTestCase implements ApplicationContextAware {
...
Alguém tem alguma idéia? Geralmente, é uma má idéia combinar essas duas estruturas?
EDIT: Aqui está o restante da fonte da classe de teste:
@TestExecutionListeners
@ContextConfiguration(locations = "/testdao.xml")
public class SimpleJPATest extends DBTestCase implements ApplicationContextAware {
static final String TEST_DB_PROPS_FILE = "testDb.properties";
static final String DATASET_FILE = "testDataSet.xml";
static Logger logger = Logger.getLogger( SimpleJPATest.class );
private ApplicationContext ctx;
public SimpleJPATest() throws Exception {
super();
setDBUnitSystemProperties(loadDBProperties());
}
@Test
public void testSimple() {
EntityManagerFactory emf = ctx.getBean("entityManagerFactory", EntityManagerFactory.class);
EntityManager em = emf.createEntityManager();
GenericDAO<Club> clubDAO = new JpaGenericDAO<Club>(ClubEntity.class, "ClubEntity", em);
em.getTransaction().begin();
Collection<Club> allClubs = clubDAO.findAll();
em.getTransaction().commit();
assertEquals(1, allClubs.size());
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.ctx = applicationContext;
}
private void setDBUnitSystemProperties(Properties props) {
System.setProperty(PropertiesBasedJdbcDatabaseTester.DBUNIT_DRIVER_CLASS,
props.getProperty("db.driver"));
System.setProperty(PropertiesBasedJdbcDatabaseTester.DBUNIT_CONNECTION_URL,
props.getProperty("db.url"));
System.setProperty(PropertiesBasedJdbcDatabaseTester.DBUNIT_USERNAME,
props.getProperty("db.username"));
System.setProperty(PropertiesBasedJdbcDatabaseTester.DBUNIT_PASSWORD,
props.getProperty("db.password"));
}
private Properties loadDBProperties() throws Exception {
URL propsFile = ClassLoader.getSystemResource(TEST_DB_PROPS_FILE);
assert (propsFile != null);
Properties props = new Properties();
props.load(propsFile.openStream());
return props;
}
@Override
protected void setUpDatabaseConfig(DatabaseConfig config) {
config.setProperty( DatabaseConfig.PROPERTY_DATATYPE_FACTORY,
new HsqldbDataTypeFactory() );
}
@Override
protected DatabaseOperation getSetUpOperation() throws Exception {
return DatabaseOperation.CLEAN_INSERT;
}
@Override
protected DatabaseOperation getTearDownOperation() throws Exception {
return DatabaseOperation.DELETE_ALL;
}
@Override
protected IDataSet getDataSet() throws Exception {
logger.debug("in getDataSet");
URL dataSet = ClassLoader.getSystemResource(DATASET_FILE);
assert (dataSet != null);
FlatXmlDataSet result = new FlatXmlDataSetBuilder().build(dataSet);
return result;
}
}
Solução
Eu usei essas duas estruturas juntas sem problemas. Eu tive que fazer algumas coisas um pouco diferentes do padrão para fazer com que funcione:
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:applicationContext.xml" })
@TestExecutionListeners({ DependencyInjectionTestExecutionListener.class,
DirtiesContextTestExecutionListener.class })
public class MyDaoTest extends DBTestCase {
@Autowired
private MyDao myDao;
/**
* This is the underlying BasicDataSource used by Dao. If The Dao is using a
* support class from Spring (i.e. HibernateDaoSupport) this is the
* BasicDataSource that is used by Spring.
*/
@Autowired
private BasicDataSource dataSource;
/**
* DBUnit specific object to provide configuration to to properly state the
* underlying database
*/
private IDatabaseTester databaseTester;
/**
* Prepare the test instance by handling the Spring annotations and updating
* the database to the stale state.
*
* @throws java.lang.Exception
*/
@Before
public void setUp() throws Exception {
databaseTester = new DataSourceDatabaseTester(dataSource);
databaseTester.setDataSet(this.getDataSet());
databaseTester.setSetUpOperation(this.getSetUpOperation());
databaseTester.onSetup();
}
/**
* Perform any required database clean up after the test runs to ensure the
* stale state has not been dirtied for the next test.
*
* @throws java.lang.Exception
*/
@After
public void tearDown() throws Exception {
databaseTester.setTearDownOperation(this.getTearDownOperation());
databaseTester.onTearDown();
}
/**
* Retrieve the DataSet to be used from Xml file. This Xml file should be
* located on the classpath.
*/
@Override
protected IDataSet getDataSet() throws Exception {
final FlatXmlDataSetBuilder builder = new FlatXmlDataSetBuilder();
builder.setColumnSensing(true);
return builder.build(this.getClass().getClassLoader()
.getResourceAsStream("data.xml"));
}
/**
* On setUp() refresh the database updating the data to the data in the
* stale state. Cannot currently use CLEAN_INSERT due to foreign key
* constraints.
*/
@Override
protected DatabaseOperation getSetUpOperation() {
return DatabaseOperation.CLEAN_INSERT;
}
/**
* On tearDown() truncate the table bringing it back to the state it was in
* before the tests started.
*/
@Override
protected DatabaseOperation getTearDownOperation() {
return DatabaseOperation.TRUNCATE_TABLE;
}
/**
* Overridden to disable the closing of the connection for every test.
*/
@Override
protected void closeConnection(IDatabaseConnection conn) {
// Empty body on purpose.
}
// Continue TestClass here with test methods.
Eu tive que fazer as coisas um pouco mais manual do que gostaria, mas o mesmo cenário se aplica se você tentar usar o corredor parametrizado do Junit com a primavera (nesse caso, você precisa iniciar o TextContext manualmente). A coisa mais importante a ser observada é que substituo o método CloseConnection () e deixo -o em branco. Isso substitui a ação padrão de fechar a conexão com o DataSource após cada teste, que pode adicionar tempo desnecessário, pois a conexão terá que ser reaberta após cada teste.