Obtenir LazyInitializationException sur les Cas de Test JUnit

Problème d'exécution de Test JUnit à l'intérieur d'un Spring MVC de l'Application. Test 1 (insertTweet) semble fonctionner bien, mais sur le Test 2-je obtenir un "LazyInitializationException" Exception (voir texte intégral de stactrace ci-dessous). Je comprends pourquoi il est jeté mais vous ne savez pas pourquoi la session de clôture et la façon de l'ouvrir à nouveau au début de chaque test 2 (ou garder la session ouverte pour le reste des tests à compléter)? J'ai collé l'ensemble de la StackTrace jetées avec des Classes de Test.

org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: com.project.user.User.tweets, could not initialize proxy - no Session
at org.hibernate.collection.internal.AbstractPersistentCollection.throwLazyInitializationException(AbstractPersistentCollection.java:566)
at org.hibernate.collection.internal.AbstractPersistentCollection.withTemporarySessionIfNeeded(AbstractPersistentCollection.java:186)
at org.hibernate.collection.internal.AbstractPersistentCollection.initialize(AbstractPersistentCollection.java:545)
at org.hibernate.collection.internal.AbstractPersistentCollection.write(AbstractPersistentCollection.java:370)
at org.hibernate.collection.internal.PersistentBag.add(PersistentBag.java:291)
at com.project.core.tweet.Tweet.<init>(Tweet.java:113)
at com.project.core.service.impl.FanoutServiceTester.insertTweet(FanoutServiceTester.java:69)
at com.project.core.service.impl.FanoutServiceTester.testInsertRetweet(FanoutServiceTester.java:62)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:601)
at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:44)
at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15)
at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:41)
at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20)
at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:28)
at org.springframework.test.context.junit4.statements.RunBeforeTestMethodCallbacks.evaluate(RunBeforeTestMethodCallbacks.java:74)
at org.springframework.test.context.junit4.statements.RunAfterTestMethodCallbacks.evaluate(RunAfterTestMethodCallbacks.java:83)
at org.springframework.test.context.junit4.statements.SpringRepeat.evaluate(SpringRepeat.java:72)
at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:231)
at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:88)
at org.junit.runners.ParentRunner$3.run(ParentRunner.java:193)
at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:52)
at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:191)
at org.junit.runners.ParentRunner.access$000(ParentRunner.java:42)
at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:184)
at org.springframework.test.context.junit4.statements.RunBeforeTestClassCallbacks.evaluate(RunBeforeTestClassCallbacks.java:61)
at org.springframework.test.context.junit4.statements.RunAfterTestClassCallbacks.evaluate(RunAfterTestClassCallbacks.java:71)
at org.junit.runners.ParentRunner.run(ParentRunner.java:236)
at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.run(SpringJUnit4ClassRunner.java:174)
at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:50)
at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)
@RunWith(SpringJUnit4ClassRunner.class)
@TestExecutionListeners({ServiceTestExecutionListener.class})
@ActiveProfiles("test")
public abstract class AbstractServiceImplTest extends AbstractTransactionalJUnit4SpringContextTests {
@PersistenceContext
protected EntityManager em;
@Autowired protected TweetService tweetService;
@Autowired protected UserService userService;
}
public class FanoutServiceTester extends AbstractServiceImplTest{
private static User user = null;
private static User userTwo = null;
@Before
public void setUp() throws Exception {
user = userService.findByUserId(1);
//UserTwo Follows User One
userTwo  = userService.findByUserId(2);
}
@Test
public final void testInsertTweet() {       
insertTweet();
//Assert Here
}
@Test
public final void testInsertRetweet() {
insertTweet();
//Assert Here
}
private Tweet insertTweet(){
Tweet tweet = new Tweet(user);
String text = "This is a Message";  
tweet.setTweetText(text);
Tweet saved = tweetService.save(tweet);
return saved;
}
}
Qu'attendez-vous de nous faire avec ce que vous avez montré? Poster votre configuration et de votre test.

OriginalL'auteur Jamie White | 2013-11-06

  1. 2

    J'ai couru dans le présent et l'erreur est un peu trompeur. Le Session n'est pas fermé.

    Lorsque vous appelez userService.findByUserId(1); il est sans doute un Join à un Tweets table et ainsi, vous obtenez cette collection dos:

    com.project.user.User.tweets

    Hibernate ne pas initialiser cette collection par défaut. Pour l'initialiser, vous pouvez appeler Hibernate.initialize() par exemple, comme ceci:

    Hibernate.initialize(user.getTweets());

    De cours suppléant getTweets() pour la méthode qui retourne la tweets collection.

    Qui semble fonctionner. Cependant, je travaille avec JPA 2 et ayant une "mise en veille prolongée.initialize()" à l'intérieur d'une Entité JPA me semble bizarre. Se pourrait-il que junit est l'appel de veille prolongée au lieu de jpa?
    Oui ça serait bizarre 🙂 Alors la Tweets collection de l'entité doivent être récupérées avec impatience (il est paresseux, c'est à dire récupéré mais pas initialisé, par défaut). Essayez en annotant avec @OneToMany(fetch=FetchType.EAGER)
    Je ne suis pas sûr de ce que tu veux dire? À moins que je me manque quelque chose, Si j'ai choisi de le définir "avec Impatience" la Charge de la Collection, je l'attends pour le faire. D'ailleurs, j'aimerais épuisé toutes les autres options.
    Quel est le problème avec impatience le chargement de la collection, dans ce cas?
    Les Tweets Collection peut contenir un grand nombre d'enregistrements. Si j'étais à "avec Impatience" la Charge de cette Collecte alors chaque fois que je charge la "Utilisateur" de l'Objet, il sera aussi charger les Tweets de la Collection, ce qui peut conduire à des problèmes de performances.

    OriginalL'auteur roark

  2. 45

    ajouter le @Transactional sur vos méthodes d'essai – ben75 Nov 6 '13 à 14:29

    Ouais, j'ai résolu le problème:

            @RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath*:applicationContext.xml"})
@Transactional
public class UserinfoActionTest extends StrutsSpringJUnit4TestCase<UserinfoAction> {
@Test
public void testLogin2(){
request.setParameter("jsonQueryParam", param);
String str = null;
try {
str = executeAction("/login.action");
HashMap<String,List<TUserinfo>> map = (HashMap<String,List<TUserinfo>>)findValueAfterExecute("outDataMap"); }
catch (Exception e) {
e.printStackTrace();
}
}
@Controller
@Results({  
@Result(name="json",type="json"
, params={"root","outDataMap","excludeNullProperties","true"
,"excludeProperties","^ret\\[\\d+\\]\\.city\\.province,^ret\\[\\d+\\]\\.enterprise\\.userinfos","enableGZIP","true"
})
})
public class UserinfoAction extends BaseAction {
@Action(value="login")
public String login(){
if(jsonQueryParam!=null && jsonQueryParam.length()>0)
{
user = JsonMapper.fromJson(jsonQueryParam, TUserinfo.class);
}
Assert.notNull(user);
//RESULT="ret" addOutJsonData: put List<TUserinfo> into outDataMap with key RESULT for struts2 JSONResult  
addOutJsonData(RESULT, service.login(user));
return JSON;
}
    L'ajout de l'org.springframework.des transactions.annotation.Transactionnel; a fonctionné pour moi
    A fonctionné pour moi!!
    Grand. les travaux de cette. Upvoting. Si il ya une chance - il serait bien d'obtenir quelques bonnes références à lire à ce sujet. Merci.
    Super! Il régler mon problème! 😀

    OriginalL'auteur uvwxyz888

  3. 10

    Il vous manque de l' TransactionalTestExecutionListener.
    Il est nécessaire et présente par défaut lorsque vous ne définissez aucune TestExecutionListener vous-même. Mais dès que vous définissez un explicitement : il est supprimé.

    Donc de le déclarer :

    @TestExecutionListeners({ServiceTestExecutionListener.class, TransactionalTestExecutionListener.class})

    Voir "Tests - gestion des Transactions" de la 3.2.x le Printemps docs.

    J'ai fait les modifications suggérées, mais je suis encore en train de le mentionné exception.
    ajouter le @Transactional sur vos méthodes de test
    J'ai ajouté que trop. Je pense que tout ce qui n'est pas nécessaire si vous êtes l'extension de AbstractTransactionalJUnit4Springcontexttests Classe, ce que je fais.
    J'ai eu le même problème résolu en cas de test JUnit par le simple ajout de TransactionalTestExecutionListener pour les auditeurs. Merci. 🙂

    OriginalL'auteur ben75