Printemps + TestNG les tests d'intégration, l'injection de DAO avec des annotations échoue
J'ai d'abord ne pas mentionner ce qui a été l'élément clé de ce problème: je suis en utilisant TestNG ici.
J'ai un DAO de l'exécution de la couche de persistance. Il fonctionne très bien comme une partie de ma petite application web (j'ai une manette classique, Service, DAO couches de la conception). Je peux mettre à jour cette question avec mon XMLs si nécessaire.
Ma couche de Service
@Service
public class UserServiceImpl implements UserService {
@Autowired
private UserDao userDao;
@Override
public GoodVibeUserDetails getUser(String username) throws UsernameNotFoundException {
GoodVibeUserDetails user = userDao.getDetailsRolesAndImagesForUser(username);
return user;
}
//more methods...
}
Mon DAO couche
@Repository
public class UserDaoImplHibernate implements UserDao {
@Autowired
private SessionFactory sessionFactory;
//My methods using sessionFactory & "talking" to the Db via the sessionFactory
}
Et voici ma Classe de Test
@Component
public class UserDaoImplHibernateTests{
@Autowired
private UserDao userDao;
private GoodVibeUserDetails user;
@BeforeMethod
public void beforeEachMethod() throws ParseException{
user = new GoodVibeUserDetails();
user.setUsername("adrien");
user.setActive(true);
//& so on...
}
/*
* When everything is fine - test cases
*/
@Test
public void shouldAcceptRegistrationAndReturnUserWithId() throws Exception{
assertNotNull(userDao) ;
user = userDao.registerUser(user);
assertNotNull(user.getId()) ;
}
//more test cases...
}
Mais pour ma classe de test l'permettra à l'autowiring, userDao
retourne toujours Null, je ne fais que de commencer à faire des tests au Printemps et je suis un peu perdu. Tous les pointeurs sont les bienvenus.
Dernière modification après Boris Treukhov la réponse de
import ...
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import static org.junit.Assert.assertNotNull;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/applicationContext.xml")
public class UserDaoImplHibernateTests{
@Autowired
@Qualifier("userDao")
private UserDao userDao;
private GoodVibeUserDetails user;
@BeforeMethod
public void beforeEachMethod() throws ParseException{
user = new GoodVibeUserDetails();
user.setUsername("adrien");
user.setActive(true);
//& so on...
}
/*
* When everything is fine - test cases
*/
@Test
public void shouldAcceptRegistrationAndReturnUserWithId() throws Exception{
assertNotNull(userDao) ;
user = userDao.registerUser(user);
assertNotNull(user.getId()) ;
}
//more test methods...
}
Et c'est mon applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd" >
<!-- the application context definition scans within the base package of the application -->
<!-- for @Components, @Controller, @Service, @Configuration, etc. -->
<context:annotation-config />
<context:component-scan base-package="com.goodvibes" />
<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer" p:location="/WEB-INF/jdbc.properties" />
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"
p:driverClassName="${jdbc.driverClassName}" p:url="${jdbc.databaseurl}"
p:username="${jdbc.username}" p:password="${jdbc.password}" />
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="configLocation">
<value>classpath:hibernate.cfg.xml</value>
</property>
<property name="configurationClass">
<value>org.hibernate.cfg.AnnotationConfiguration</value>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">${jdbc.dialect}</prop>
<prop key="hibernate.show_sql">${jdbc.show_sql}</prop>
<prop key="hibernate.connection.SetBigStringTryClob">true</prop>
<prop key="hibernate.jdbc.batch_size">0</prop>
</props>
</property>
</bean>
<tx:annotation-driven />
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
[...]
</beans>
Je n'ai pas ajouter un repository-config.xml comme cela devrait être suffisant pour accéder à userDao
. Je reçois encore des userDao égal à null.
Merci d'avance
OriginalL'auteur Adrien Be | 2012-10-26
Vous devez vous connecter pour publier un commentaire.
Si vous créer des tests unitaires, Printemps Cio fonctionnalité n'est pas disponible(comme il était prévu par le cadre de designers), parce que vous testez vos objets en isolation(par exemple: vous êtes moqueur uniquement un ensemble d'interfaces qui sont nécessaires pour le test). Dans ce cas, vous devez injecter votre maquette référentiel manuellement, par exemple dans le @Avant de tester une méthode d'initialisation. L'idée est que les classes ne dépendent que des interfaces, donc, fondamentalement, Printemps conteneur évalue la classe à utiliser comme interface de mise en œuvre, mais lorsque vous créez une unité de test, vous devez avoir un contrôle strict de l'interface des méthodes ont été appelés(et avoir un minimum d'ensemble de dépendances), c'est pourquoi vous devez effectuer l'injection manuellement.
Si vous faites des tests d'intégration, vous devriez avoir un Printemps conteneur IoC instance et en cours d'exécution, pour que cela fonctionne, vous devez utiliser jUnit(en supposant que vous êtes en utilisant jUnit) test spécifique coureur, comme il est décrit dans le Le printemps de la documentation sur les essais.
Donc, pour revenir à la question, vous avez ce qui ressemble à une simple unité de test jUnit, et le Printemps conteneur n'est pas utilisé. Donc, si vous allez utiliser Spring framework TestContext, vous devriez avoir quelque chose comme
au lieu de
@Component
.mise à jour dans TestNg cas, je pense qu'il devrait être (j'ai utilisé Le printemps de l'Injection de Dépendances avec TestNG comme la référence)
Voir aussi: Quelle est la différence entre l'intégration et les tests unitaires?
supprimer la
@Qualifier("userDao")
que vous n'avez pas spécifié le nom de@Repository
annotation de UserDaoImplHibernate est supposer qu'il en sera userDaoImplHibernate (mais je n'ai pas rememeber exactement :-), de toute façon, à l'aide de qualificateur de nom est absolument inutile ici.pas de chance, encore userDao est égal à null
êtes-vous vraiment exécuter ce projet comme un test avec jUnit 4+? Avez-vous des messages d'erreur dans la console?
stackoverflow.com/questions/2608528/...
OriginalL'auteur Boris Treukhov