CannotCreateTransactionException avec JUnit

Version imprimable

Je suis en train de realiser des tests avec Junit.
J'ai l'exception ci-dessus qui se produit lorsque j'execute tous mes tests ensemble alors que si je les execute separement, tout va bien.
Et je ne vois pas vraiment quelle peut en etre la cause, quelque chose qui ne permettrait pas plusieurs transactions en meme temps?
Voici les sources (c'est un peu long):

AbstractSpringConfiguration

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
/**
 * Bussiness unit:<br>
 * Project: Subvencions<br>
 * ClassName: net.gencat.dptop.subvencions.test.services.configuration.AbstractSpringConfiguration.java<br>
 * Description: <br>
 * Copyright: Copyright (c) 2006<br>
 * Company: Atos Origin<br>
 * Date: 14-dic-2006<br>
 *
 * @author MMR
 *
 */
package net.gencat.uid.test.services.configuration;
 
import junit.framework.TestCase;
 
import net.opentrends.openframe.services.logging.LoggingService;
 
import org.acegisecurity.GrantedAuthority;
import org.acegisecurity.GrantedAuthorityImpl;
import org.acegisecurity.context.SecurityContext;
import org.acegisecurity.context.SecurityContextHolder;
import org.acegisecurity.providers.UsernamePasswordAuthenticationToken;
import org.acegisecurity.userdetails.User;
import org.acegisecurity.userdetails.UserDetails;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
 
/**
 * Configuration test case
 *
 */
public class AbstractSpringConfiguration extends TestCase {
    /**
     * The application context
     */
    private ClassPathXmlApplicationContext applicationContext = null;
 
    /**
     * Shortcut to loggingService
     */
    private LoggingService loggingService = null;
 
    /**
     * True if setUp has been called
     */
    private boolean initialized = false;
 
    /**
     * Setup application context
     */
    protected void setUp() throws Exception {
        if (!initialized) {
            this.applicationContext = new ClassPathXmlApplicationContext(new String[] {
                        "spring/applicationContextTest.xml"
                    });
            this.loggingService = (LoggingService) this.applicationContext.getBean("loggingService");
            this.initialized = true;
            if (this.loggingService != null) {
                this.loggingService.getLog(this.getClass()).info("Initialized from AbstractSpringConfiguration");
            }
        }
    }
 
	/**
         * initializing security context
         * @param username
         * @param password
         * @param roles
         */
    public void setAuthentication(String username,String password,String[] roles){
    	GrantedAuthority[] granted=new GrantedAuthority[roles.length];
    	for (int i=0;i<roles.length;i++){
    		granted[i]=new GrantedAuthorityImpl(roles[i]);
    	}
 
    	UserDetails user=new User(username,password,true,true,true,true, granted);
        UsernamePasswordAuthenticationToken token; 
        token=new UsernamePasswordAuthenticationToken(user, username,  granted);
        SecurityContext secureContext = (SecurityContext) SecurityContextHolder.getContext();
        secureContext.setAuthentication(token);
        SecurityContextHolder.setContext(secureContext);
    }
    /**
     * @return Returns the applicationContext.
     */
    public ClassPathXmlApplicationContext getApplicationContext() {
        return applicationContext;
    }
 
    /**
     * @param applicationContext The applicationContext to set.
     */
    public void setApplicationContext(
        ClassPathXmlApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }
 
    /**
     * @return Returns the loggingService.
     */
    public LoggingService getLoggingService() {
        return loggingService;
    }
 
    /**
     * @param loggingService The loggingService to set.
     */
    public void setLoggingService(LoggingService loggingService) {
        this.loggingService = loggingService;
    }
 
    /**
     * @return Returns the initialized.
     */
    public boolean isInitialized() {
        return initialized;
    }
 
    /**
     * @param initialized The initialized to set.
     */
    public void setInitialized(boolean initialized) {
        this.initialized = initialized;
    }
}

Mon test TascaBOTest:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
package net.gencat.uid.test.model.param.tasca;
 
import net.gencat.uid.general.Constantes;
import net.gencat.uid.model.param.tasca.Tasca;
import net.gencat.uid.model.param.tasca.TascaBO;
import net.gencat.uid.model.param.tasca.TascaDocumentBO;
import net.gencat.uid.model.param.tasca.TascaPlantillaBO;
import net.gencat.uid.test.services.configuration.AbstractSpringConfiguration;
 
public class TascaBOTest extends AbstractSpringConfiguration{
	private TascaBO bo;
	private Tasca tasca=null;
	protected void setUp() throws Exception{
		super.setUp();
		this.bo=(TascaBO) this.getApplicationContext().getBean("tascaBOTarget");
		this.bo.setTascaDocumentBo((TascaDocumentBO) this.getApplicationContext().getBean("tascaDocumentBOTarget"));
		this.bo.setTascaPlantillaBo((TascaPlantillaBO)this.getApplicationContext().getBean("tascaPlantillaBOTarget"));
		setAuthentication("better","better",new String[]{"ROLE_PARAM_ADMIN"});
 
		tasca=new Tasca();
		tasca.setTqsys(Constantes.getTipusSystem());
		tasca.setTqcodi("TASCATEST1");
		tasca.setTqtipus("NOT");
		tasca.setTqdescripcio("Descripcio de tasca de test");
		tasca.setTqperfil("better_provas");
	}
	public void testCRUD1(){
		assertNotNull(getBo());
		assertNotNull(tasca);
 
		String value=bo.save(tasca);	//crear un nuevo registro
		assertEquals(value.length(),0);
		value=bo.save(tasca);			//crear un nuevo registro que existe ya
		assertFalse(value.length()==0);
 
		Tasca tascaGet=bo.get(tasca.getTqcodi());	//leer un registro que existe
		assertNotNull(tascaGet);
		assertEquals(tascaGet,tasca);
		assertNotSame(tascaGet,tasca);
 
		tascaGet.setTqdescripcio("Description modified");	//modificar un registro
		bo.saveOrUpdate(tascaGet);			
		assertFalse(tascaGet.getTqdescripcio().equals(tasca.getTqdescripcio()));
 
		bo.delete(tascaGet);							//borrar un registro
		assertNull(bo.get(tasca.getTqcodi()));		//leer un registro que no existe
	}
	public void testCRUD2(){
		Tasca tq=new Tasca();
		tq.setTqsys(Constantes.getTipusSystem());
		tq.setTqcodi("TASCATEST2");
		tq.setTqtipus("DEC");
		tq.setTqdescripcio("Descripcio de tasca de test");
		tq.setTqpregavis("text de la decissió");
		tq.setTqperfil("better_provas");
		testCRUD(tq);
 
		Tasca tq1=new Tasca();
		tq1.setTqsys(Constantes.getTipusSystem());
		tq1.setTqcodi("TASCATEST3");
		tq1.setTqtipus("AVI");
		tq1.setTqdescripcio("Descripcio de tasca de test");
		tq1.setTqpregavis("text del avis");
		tq1.setTqperfil("better_provas");
		testCRUD(tq1);
 
		Tasca tq2=new Tasca();
		tq2.setTqsys(Constantes.getTipusSystem());
		tq2.setTqcodi("TASCATEST4");
		tq2.setTqtipus("ESP");
		tq2.setTqdescripcio("Descripcio de tasca de test");
		tq2.setTqtempsespera(5);
		tq2.setTqperfil("better_provas");
		testCRUD(tq2);
	}
	private void testCRUD(Tasca tq){
		assertNotNull(getBo());
		assertNotNull(tq);
 
		String value=bo.save(tq);	//crear un nuevo registro
		assertEquals(value.length(),0);
		value=bo.save(tq);			//crear un nuevo registro que existe ya
		assertFalse(value.length()==0);
 
		Tasca tqGet=bo.get(tq.getTqcodi());	//leer un registro que existe
		assertNotNull(tqGet);
		assertEquals(tqGet,tq);
		assertNotSame(tqGet,tq);
 
		tqGet.setTqdescripcio("Description modified");	//modificar un registro
		bo.saveOrUpdate(tqGet);			
		assertFalse(tqGet.getTqdescripcio().equals(tq.getTqdescripcio()));
 
		bo.delete(tqGet);							//borrar un registro
		assertNull(bo.get(tq.getTqcodi()));		//leer un registro que no existe
	}
	public TascaBO getBo() {
		return bo;
	}
	public void setBo(TascaBO bo) {
		this.bo = bo;
	}
}

Le Business Object a tester TascaBO:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
public class TascaBO {
	private DAO dao;
	private SecurityService securityService;
	private TascaPlantillaBO tascaPlantillaBo;	
	private TascaDocumentBO tascaDocumentBo;
 
	public String save(Tasca tq) throws PersistenceServiceException{
		if(get(tq.getTqcodi())!=null){
			return "net.gencat.uid.exception.insert.primary_key";
		}
		String msg=this.validateTasca(tq);
		if (msg.length()!=0){
			return msg;
		}
		tq.setTqsys(Constantes.getTipusSystem());
		tq.setTqdataalta(new Date());
		tq.setTqdataedicio(new Date());
	    tq.setTqusuari(securityService.getUserLogin().getUserName());
		dao.save(tq);
		return "";
	}	
	public void refresh(Tasca tq) throws PersistenceServiceException{
		tq.setTqsys(Constantes.getTipusSystem());
		dao.refresh(tq);
	}
	public Tasca get(String tqcodi){
		Tasca tasca=new Tasca();
		tasca.setTqcodi(tqcodi);
		tasca.setTqsys(Constantes.getTipusSystem());
		return (Tasca) dao.get(Tasca.class,tasca);
	}
	public String saveOrUpdate(Tasca tq) throws PersistenceServiceException{
		String msg=this.validateTasca(tq);
		if (msg.length()!=0){
			return msg;
		}
		tq.setTqsys(Constantes.getTipusSystem());
		tq.setTqdataedicio(new Date());
	    tq.setTqusuari(securityService.getUserLogin().getUserName());
	  	dao.saveOrUpdate(tq);
	  	return "";
	}
	public String delete(Tasca tq) throws PersistenceServiceException{
		if ( ( !hasTascaDocument(tq.getTqcodi()) ) && ( !hasTascaPlantilla(tq.getTqcodi()) ) ){
			refresh(tq);
			dao.delete(tq);
			return "";
		}else{
			return "net.gencat.uid.exception.delete.foreign_key";
		}
	}
	public String getEstatDefecte(Tasca tq) throws PersistenceServiceException{
		List params = dao.getHibernateSession().createCriteria(ParametreGeneral.class)
		    .add( Restrictions.eq("pgsys", Constantes.getTipusSystem()) )
		    .add( Restrictions.eq("pgtipus", "TIPUSTASCA") )
		    .add( Restrictions.eq("pgnom", tq.getTqtipus() ) )
		    .list();
		ParametreGeneral pg=(ParametreGeneral)params.get(0);
		return pg.getPgvalor1();
	}
	private boolean hasTascaDocument(String tqcodi){
		String[] propNames = {"tqcodi", "tdsys"};
		Object[] filters = new Object[2];  
		filters[0] = tqcodi;
		filters[1] = Constantes.getTipusSystem();
		List tqList=getTascaDocumentBo().findFiltered(propNames,filters);
		return !(tqList.isEmpty());
	}
 
	private boolean hasTascaPlantilla(String tqcodi){
		String[] propNames = {"tqcodi", "tpsys"};
		Object[] filters = new Object[2];  
		filters[0] = tqcodi;
		filters[1] = Constantes.getTipusSystem();
		List tqList=getTascaPlantillaBo().findFiltered(propNames,filters);
		return !(tqList.isEmpty());
	}
	private String validateTasca(Tasca tq){
		if ( tq.getTqtipus().equals("DEC") || tq.getTqtipus().equals("AVI") ){
			if ( tq.getTqpregavis()==null || tq.getTqpregavis().length()==0)
				return "net.gencat.uid.exception.tasca.tipustasca.required";
		}
		if ( tq.getTqtipus().equals("ESP") ){
			if (tq.getTqtempsespera()<=0){
				return "net.gencat.uid.exception.tasca.tempsespera.menorcero";
			}
		}
		return "";
	}
	//-------------- GETTERS AND SETTERS ---------
	public TascaDocumentBO getTascaDocumentBo() {
		return tascaDocumentBo;
	}
	public void setTascaDocumentBo(TascaDocumentBO tascaDocumentBo) {
		this.tascaDocumentBo = tascaDocumentBo;
	}
	public TascaPlantillaBO getTascaPlantillaBo() {
		return tascaPlantillaBo;
	}
	public void setTascaPlantillaBo(TascaPlantillaBO tascaPlantillaBo) {
		this.tascaPlantillaBo = tascaPlantillaBo;
	}
	public DAO getDao() {
		return dao;
	}
	public void setDao(DAO dao) {
		this.dao = dao;
	}
	public SecurityService getSecurityService() {
		return securityService;
	}
	public void setSecurityService(SecurityService securityService) {
		this.securityService = securityService;
	}
 
 
}

la trace complete de l'erreur :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
org.springframework.transaction.CannotCreateTransactionException: Could not open Hibernate Session for transaction; nested exception is org.hibernate.exception.GenericJDBCException: Cannot open connection
org.hibernate.exception.GenericJDBCException: Cannot open connection
	at org.hibernate.exception.ErrorCodeConverter.handledNonSpecificException(ErrorCodeConverter.java:92)
	at org.hibernate.exception.ErrorCodeConverter.convert(ErrorCodeConverter.java:80)
	at org.hibernate.exception.JDBCExceptionHelper.convert(JDBCExceptionHelper.java:43)
	at org.hibernate.exception.JDBCExceptionHelper.convert(JDBCExceptionHelper.java:29)
	at org.hibernate.jdbc.ConnectionManager.openConnection(ConnectionManager.java:301)
	at org.hibernate.jdbc.ConnectionManager.getConnection(ConnectionManager.java:110)
	at org.hibernate.jdbc.JDBCContext.connection(JDBCContext.java:137)
	at org.hibernate.impl.SessionImpl.connection(SessionImpl.java:345)
	at org.springframework.orm.hibernate3.HibernateTransactionManager.doBegin(HibernateTransactionManager.java:407)
	at org.springframework.transaction.support.AbstractPlatformTransactionManager.getTransaction(AbstractPlatformTransactionManager.java:281)
	at org.springframework.transaction.interceptor.TransactionAspectSupport.createTransactionIfNecessary(TransactionAspectSupport.java:217)
	at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:89)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:144)
	at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:174)
	at $Proxy2.findFiltered(Unknown Source)
	at net.gencat.uid.model.param.tasca.TascaPlantillaBO.findFiltered(TascaPlantillaBO.java:30)
	at net.gencat.uid.model.param.tasca.TascaBO.hasTascaPlantilla(TascaBO.java:88)
	at net.gencat.uid.model.param.tasca.TascaBO.delete(TascaBO.java:57)
	at net.gencat.uid.test.model.param.tasca.TascaBOTest.testCRUD(TascaBOTest.java:94)
	at net.gencat.uid.test.model.param.tasca.TascaBOTest.testCRUD2(TascaBOTest.java:74)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
	at java.lang.reflect.Method.invoke(Method.java:585)
	at junit.framework.TestCase.runTest(TestCase.java:154)
	at junit.framework.TestCase.runBare(TestCase.java:127)
	at junit.framework.TestResult$1.protect(TestResult.java:106)
	at junit.framework.TestResult.runProtected(TestResult.java:124)
	at junit.framework.TestResult.run(TestResult.java:109)
	at junit.framework.TestCase.run(TestCase.java:118)
	at junit.framework.TestSuite.runTest(TestSuite.java:208)
	at junit.framework.TestSuite.run(TestSuite.java:203)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:478)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:344)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:196)
Caused by: java.sql.SQLException: Listener refused the connection with the following error:
ORA-12519, TNS:no appropriate service handler found
The Connection descriptor used by the client was:
127.0.0.1:1521:xe
 
	at oracle.jdbc.driver.DatabaseError.throwSqlException(DatabaseError.java:145)
	at oracle.jdbc.driver.DatabaseError.throwSqlException(DatabaseError.java:380)
	at oracle.jdbc.driver.T4CConnection.logon(T4CConnection.java:401)
	at oracle.jdbc.driver.PhysicalConnection.<init>(PhysicalConnection.java:441)
	at oracle.jdbc.driver.T4CConnection.<init>(T4CConnection.java:165)
	at oracle.jdbc.driver.T4CDriverExtension.getConnection(T4CDriverExtension.java:35)
	at oracle.jdbc.driver.OracleDriver.connect(OracleDriver.java:839)
	at java.sql.DriverManager.getConnection(DriverManager.java:525)
	at java.sql.DriverManager.getConnection(DriverManager.java:140)
	at org.springframework.jdbc.datasource.DriverManagerDataSource.getConnectionFromDriverManager(DriverManagerDataSource.java:290)
	at org.springframework.jdbc.datasource.DriverManagerDataSource.getConnectionFromDriverManager(DriverManagerDataSource.java:276)
	at org.springframework.jdbc.datasource.DriverManagerDataSource.getConnectionFromDriverManager(DriverManagerDataSource.java:258)
	at org.springframework.jdbc.datasource.DriverManagerDataSource.getConnection(DriverManagerDataSource.java:240)
	at org.springframework.orm.hibernate3.LocalDataSourceConnectionProvider.getConnection(LocalDataSourceConnectionProvider.java:80)
	at org.hibernate.jdbc.ConnectionManager.openConnection(ConnectionManager.java:298)
	... 30 more

23/04/2007, 15h04
trungsi

Je n'ai pas la réponse exacte à ton problème. Je pense qu'il n'y a plus de transaction lorsque bo.delete() dans la méthod testCRUD() est appelée. Spring fournit la classe AbstractTransactionalDataSourceSpringContextTests pour les tests unitaires avec Spring. L'avantage de cette classe, c'est que Spring démarre automatiquement une transaction pour chaque test case et rollback la transaction à la fin. En plus, tu ne dois plus construire manuellement applicationContext, il suffit de fournir le chemin vers les fichiers de conf.
Si tu adapte AbstractSpringConfiguration en héritant de AbstractTransactionalDataSourceSpringContextTests, ton problème va être résolu.

Alors voila, j'ai essaye avec AbstractTransactionalDataSourceSpringContextTests mais je me retrouve avec une erreur un peu etrange qui si je comprends bien me dis que ne peux pas utiliser plus d'un bean de type java.sql.DataSource.
Hors j'ai besoin de ca car j'ai un datasource pour le service de securite (avec acegi) et un autre relatif a mon appli.Que faire ?

Voici la trace complete de l'erreur :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'net.gencat.uid.test.services.configuration.AbstractTransactionSpringConfigurationTest' defined in null: Unsatisfied dependency expressed through bean property 'dataSource': There are 2 beans of type [interface javax.sql.DataSource] for autowire by type. There should have been 1 to be able to autowire property 'dataSource' of bean 'net.gencat.uid.test.services.configuration.AbstractTransactionSpringConfigurationTest'.
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.autowireByType(AbstractAutowireCapableBeanFactory.java:896)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean(AbstractAutowireCapableBeanFactory.java:816)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.autowireBeanProperties(AbstractAutowireCapableBeanFactory.java:200)
	at org.springframework.test.AbstractDependencyInjectionSpringContextTests.setUp(AbstractDependencyInjectionSpringContextTests.java:138)
	at junit.framework.TestCase.runBare(TestCase.java:125)
	at junit.framework.TestResult$1.protect(TestResult.java:106)
	at junit.framework.TestResult.runProtected(TestResult.java:124)
	at junit.framework.TestResult.run(TestResult.java:109)
	at junit.framework.TestCase.run(TestCase.java:118)
	at junit.framework.TestSuite.runTest(TestSuite.java:208)
	at junit.framework.TestSuite.run(TestSuite.java:203)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:478)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:344)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:196)

Sinon, sans utiliser cette fameuse classe, est-il possible de faire un rollback "a la main" ?

10/05/2007, 14h05
trungsi

Je pense que tes beans sont injectés "by Type" (autowire="byType") et comme il y a 2 datasources dans configurées, Spring ne sait pas prend laquelle. Il faut soit modifier le mode autowire à byName, soit configurer précisement la datasource pour chaque bean. Peux tu faire voir le code source de la classe net.gencat.uid.test.services.configuration.AbstractTransactionSpringConfigurationTest?

Si tu veux faire un rollback "à la main", il faut démarrer "à la main" la transaction. Il faut donc utiliser les classes ....TransactionManager de Spring. Pour plus de détail, il faut regarder la doc sur les parties "Transaction" et "Unit Testing".

Voila pour la classe test :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package net.gencat.uid.test.services.configuration;
 
 
/**
 * Configuration test case
 *
 */
public class AbstractTransactionSpringConfigurationTest extends AbstractTransactionSpringConfiguration {
    /**
     * Test the application context
     *
     */
    public void testSpringConfiguration() {
        assertNotNull(this.getApplicationContext());
        assertNotNull(this.getLoggingService());
        this.getLoggingService().getLog(this.getClass()).info("Loaded application context!");
    }
}

et pour la classe AbstractTransactionSpringConfiguration :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
 
package net.gencat.uid.test.services.configuration;
 
import net.opentrends.openframe.services.logging.LoggingService;
 
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.AbstractTransactionalDataSourceSpringContextTests;
 
 
/**
 * Configuration test case
 *
 */
public class AbstractTransactionSpringConfiguration extends AbstractTransactionalDataSourceSpringContextTests {
    /**
     * The application context
     */
    private ClassPathXmlApplicationContext applicationContext = null;
 
    /**
     * Shortcut to loggingService
     */
    private LoggingService loggingService = null;
 
    /**
     * True if setUp has been called
     */
    private boolean initialized = false;
 
    /**
     * @return Returns the applicationContext.
     */
    public ClassPathXmlApplicationContext getApplicationContext() {
        return applicationContext;
    }
 
    /**
     * @param applicationContext The applicationContext to set.
     */
    public void setApplicationContext(
        ClassPathXmlApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }
 
    /**
     * @return Returns the loggingService.
     */
    public LoggingService getLoggingService() {
        return loggingService;
    }
 
    /**
     * @param loggingService The loggingService to set.
     */
    public void setLoggingService(LoggingService loggingService) {
        this.loggingService = loggingService;
    }
 
    /**
     * @return Returns the initialized.
     */
    public boolean isInitialized() {
        return initialized;
    }
 
    /**
     * @param initialized The initialized to set.
     */
    public void setInitialized(boolean initialized) {
        this.initialized = initialized;
    }
	protected String[] getConfigLocations() {
		// TODO Auto-generated method stub
		return new String[] {"spring/applicationContextTest.xml"}; 
	}
}

11/05/2007, 14h11
trungsi

C'est bizzare, je ne vois pas la dépendance entre AbstractTransactionSpringConfigurationTest et DataSource alors que Spring se plainte sur ce problème.

une remarque : lorsque tu étend la classe AbstractTransactionalDataSourceSpringContextTests, pas besoin d'avoir la propriété applicationContext, elle est déjà fournie par Spring.

Voici dans mon applicationContext la partie qui se refere a l'acces aux donnees. Dans laquelle, il y'a 2 sessions factory et donc acces a deux datasources.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
<beans>
	<bean id="dataSourceUID" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName" value="${hibernate.connection.driver_class}"/>
		<property name="url" value="${hibernate.connection.url}"/>
		<property name="username" value="${hibernate.connection.username}"/>
		<property name="password" value="${hibernate.connection.password}"/>
	</bean>
 
	<!-- Hibernate SessionFactory - Servicio Seguridad -->
	<bean id="sessionFactory"
		class="net.opentrends.openframe.services.persistence.hibernate.LocalSessionFactoryBean">
		<property name="logService" ref="loggingService"/>
		<property name="mappingResources">
	      <list>      
			<value>hibernate/mappings/Warning.hbm.xml</value>
			<value>hibernate/mappings/Application.hbm.xml</value>
			<value>hibernate/mappings/UserLogin.hbm.xml</value>
			<value>hibernate/mappings/PartyGroup.hbm.xml</value>
			<value>hibernate/mappings/Role.hbm.xml</value>
	      </list>
	    </property>		
		 <property name="dataSource" ref="dataSource"/>		
		<property name="hibernateProperties">
			 <props>
			 	<prop key="hibernate.dialect">${hibernate.dialect}</prop>
			 	<prop key="hibernate.transaction.factory_class">${hibernate.transaction.factory_class}</prop>
			 	<prop key="hibernate.transaction.manager_lookup_class">${hibernate.transaction.manager_lookup_class}</prop>
			 	<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
			 	<prop key="hibernate.jdbc.use_scrollable_resultset">${hibernate.jdbc.use_scrollable_resultset}</prop>			 				 				 			
			 </props>
		</property>
	</bean>
 
	<!-- Hibernate SessionFactory - Aplicacion -->
 
<!-- Hibernate SessionFactory -->
	<bean id="sessionFactoryUID"
		class="net.opentrends.openframe.services.persistence.hibernate.LocalSessionFactoryBean">
		<property name="mappingResources">
	      <list>      
 	        <!-- Add here all your mappings -->  
			<value>hibernate/mappings/Flux.hbm.xml</value> 
			<value>hibernate/mappings/FluxTipologia.hbm.xml</value> 
			<value>hibernate/mappings/FluxTasca.hbm.xml</value> 
			<value>hibernate/mappings/Document.hbm.xml</value>  
			<value>hibernate/mappings/Tasca.hbm.xml</value> 
			<value>hibernate/mappings/TascaDocument.hbm.xml</value> 
			<value>hibernate/mappings/TascaPlantilla.hbm.xml</value> 
			<value>hibernate/mappings/Perfil.hbm.xml</value> 
			<value>hibernate/mappings/ParametreGeneral.hbm.xml</value> 
  			<value>hibernate/mappings/Plantilla.hbm.xml</value> 
  			<value>hibernate/mappings/PlantillaCamp.hbm.xml</value> 
  			<value>hibernate/mappings/PlantillaSignatura.hbm.xml</value> 
			<value>hibernate/mappings/Tipologia.hbm.xml</value> 
			<value>hibernate/mappings/TipologiaDocument.hbm.xml</value> 
			<value>hibernate/mappings/DefinicioCamp.hbm.xml</value> 
			<value>hibernate/mappings/Predecessor.hbm.xml</value> 
			<value>hibernate/mappings/Signatura.hbm.xml</value> 
			<value>hibernate/mappings/ValorsTipologies.hbm.xml</value> 
			<value>hibernate/mappings/UsuariPerfils.hbm.xml</value> 
	      </list>
	    </property>	
  	    <property name="dataSource" ref="dataSourceUID"/>
		<property name="hibernateProperties">
		 <props>
		 	<prop key="hibernate.dialect">${hibernate.dialect}</prop>
		 	<prop key="hibernate.transaction.factory_class">${hibernate.transaction.factory_class}</prop>
			<prop key="hibernate.transaction.manager_lookup_class">${hibernate.transaction.manager_lookup_class}</prop> 	
		 	<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
		 	<prop key="hibernate.jdbc.use_scrollable_resultset">${hibernate.jdbc.use_scrollable_resultset}</prop>			 				 				 			
		 </props>
		</property>
	</bean>
 
	<!--  Generic DAO to use from BOs -->
	<bean id="universalDao" class="net.opentrends.openframe.services.persistence.spring.dao.impl.UniversalDAOImpl">
		<property name="sessionFactory" ref="sessionFactoryUID" />		
	</bean>	
 
	<!-- Transaction manager for a single Hibernate SessionFactory -->
	<bean id="transactionManager"
		class="net.opentrends.openframe.services.persistence.transaction.hibernate3.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactoryUID" />
	</bean>
	<!--  Base Proxy for implementing transaction via AOP -->
	<bean id="baseProxy"
		class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
		<property name="transactionManager">
			<ref local="transactionManager" />
		</property>
		<property name="target">
			<bean class="java.lang.Object" />
		</property>
		<property name="transactionAttributes">
			<props>
				<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
				<prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
				<prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>
				<prop key="store*">PROPAGATION_REQUIRED</prop>
				<prop key="save*">PROPAGATION_REQUIRED</prop>
				<prop key="delete*">PROPAGATION_REQUIRED</prop>
				<prop key="*">PROPAGATION_REQUIRED</prop>
			</props>
		</property>
	</bean>
</beans>

22/05/2007, 10h01
trungsi

je viens d'avoir le même problème. C'était du au fait que AbstractTransactionalDataSourceSpringContextTests initialise les beans en mode "AUTOWIRE_BY_TYPE". Il faudrait utiliser le mode "AUTOWIRE_BY_NAME".

Moi perso, j'appelle la méthode setAutowireMode(AutowireCapableBeanFactory.AUTOWIRE_BY_NAME) dans le constructeur de la classe de test et ça fonctionne.