tchekai704
/
src-spring-framework
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Removed raw TopLink support

conversation
Arjen Poutsma 17 years ago
parent
11a2e40d41
commit
59d3ebebc1
7 changed files with 0 additions and 1277 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 37
      org.springframework.testsuite/src/test/java/org/springframework/orm/toplink/MockSessionFactory.java
  2. 102
      org.springframework.testsuite/src/test/java/org/springframework/orm/toplink/SessionBrokerFactoryTests.java
  3. 106
      org.springframework.testsuite/src/test/java/org/springframework/orm/toplink/SessionFactoryUtilsTests.java
  4. 98
      org.springframework.testsuite/src/test/java/org/springframework/orm/toplink/TopLinkInterceptorTests.java
  5. 321
      org.springframework.testsuite/src/test/java/org/springframework/orm/toplink/TopLinkJtaTransactionTests.java
  6. 117
      org.springframework.testsuite/src/test/java/org/springframework/orm/toplink/TopLinkTemplateTests.java
  7. 496
      org.springframework.testsuite/src/test/java/org/springframework/orm/toplink/TopLinkTransactionManagerTests.java

37
org.springframework.testsuite/src/test/java/org/springframework/orm/toplink/MockSessionFactory.java
Unescape View File

@ -1,37 +0,0 @@ @@ -1,37 +0,0 @@
package org.springframework.orm.toplink;
import oracle.toplink.sessions.Session;
/**
* @author Juergen Hoeller
* @since 28.04.2005
*/
public class MockSessionFactory implements SessionFactory {
private Session session;
public MockSessionFactory(Session session) {
this.session = session;
}
public void setSession(Session session) {
this.session = session;
}
public Session createSession() {
return this.session;
}
public Session createManagedClientSession() {
return this.session;
}
public Session createTransactionAwareSession() {
return this.session;
}
public void close() {
}
}

102
org.springframework.testsuite/src/test/java/org/springframework/orm/toplink/SessionBrokerFactoryTests.java
Unescape View File

@ -1,102 +0,0 @@ @@ -1,102 +0,0 @@
/*
* Copyright 2002-2006 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.orm.toplink;
import junit.framework.TestCase;
import oracle.toplink.exceptions.ValidationException;
import oracle.toplink.publicinterface.UnitOfWork;
import oracle.toplink.sessionbroker.SessionBroker;
import oracle.toplink.sessions.Session;
/**
* @author <a href="mailto:james.x.clark@oracle.com">James Clark</a>
*/
public class SessionBrokerFactoryTests extends TestCase {
/*
* When acquiring ClientSessionBrokers, the SessionBroker can throw RuntimeExceptions indicating
* that this SessionBroker is not capable of creating "client" Sessions. We need to handle
* these differently depending on how the SessionFactory is being used. If we are creating a
* plain Session than we can return the original SessionBroker.
*/
public void testSessionBrokerThrowingValidationException() {
SessionBroker broker = new MockSingleSessionBroker();
SessionBrokerSessionFactory factory = new SessionBrokerSessionFactory(broker);
assertEquals(factory.createSession(), broker);
try {
factory.createManagedClientSession();
fail("Should have thrown ValidationException");
}
catch (ValidationException ex) {
// expected
}
}
/**
* Insure that the managed TopLink Session proxy is behaving correctly
* when it has been initialized with a SessionBroker.
*/
public void testManagedSessionBroker() {
SessionBroker client = new MockClientSessionBroker();
SessionBroker broker = new MockServerSessionBroker(client);
SessionBrokerSessionFactory factory = new SessionBrokerSessionFactory(broker);
assertEquals(client, factory.createSession());
Session session = factory.createManagedClientSession();
assertEquals(client, session.getActiveSession());
assertNotNull(session.getActiveUnitOfWork());
assertEquals(session.getActiveUnitOfWork(), session.getActiveUnitOfWork());
}
private class MockSingleSessionBroker extends SessionBroker {
public MockSingleSessionBroker() {
}
public SessionBroker acquireClientSessionBroker() {
throw new ValidationException();
}
}
private class MockServerSessionBroker extends SessionBroker {
private SessionBroker client;
public MockServerSessionBroker(SessionBroker client) {
this.client = client;
}
public SessionBroker acquireClientSessionBroker() {
return client;
}
}
private class MockClientSessionBroker extends SessionBroker {
public MockClientSessionBroker() {
}
public UnitOfWork acquireUnitOfWork() {
return new UnitOfWork(this);
}
}
}

106
org.springframework.testsuite/src/test/java/org/springframework/orm/toplink/SessionFactoryUtilsTests.java
Unescape View File

@ -1,106 +0,0 @@ @@ -1,106 +0,0 @@
/*
* Created on Mar 18, 2005
*
*/
package org.springframework.orm.toplink;
import junit.framework.TestCase;
import oracle.toplink.sessions.Session;
import org.easymock.MockControl;
import org.springframework.transaction.support.TransactionSynchronizationManager;
/**
* @author Juergen Hoeller
* @author <a href="mailto:james.x.clark@oracle.com">James Clark</a>
* @since 28.04.2005
*/
public class SessionFactoryUtilsTests extends TestCase {
/**
* When no Session is bound and allowCreate is "false", we should throw an IllegalStateException.
* When no Session is bound, and allowCreate is "true", we should get a Session but it should not
* be bound to the Thread afterwards.
*/
public void testNoSessionBound() {
MockControl sessionControl = MockControl.createControl(Session.class);
Session session = (Session) sessionControl.getMock();
SessionFactory factory = new SingleSessionFactory(session);
session.hasExternalTransactionController();
sessionControl.setReturnValue(false, 1);
sessionControl.replay();
try {
Session boundSession = SessionFactoryUtils.getSession(factory, false);
fail();
}
catch (Throwable t) {
assertTrue(t.getClass().equals(IllegalStateException.class));
}
Session boundSession = SessionFactoryUtils.getSession(factory, true);
assertTrue(session == boundSession);
assertFalse(TransactionSynchronizationManager.hasResource(factory));
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
}
/**
* When called with no previous Session bound, "allowCreate", and "allowSynchronization",
* Session should be returned, it should be bound to the Thread, and a synchronization listener
* should be in the list of thread synchronizations.
*/
public void testNoSessionBoundAllowAndInit() {
MockControl sessionControl = MockControl.createControl(Session.class);
Session session = (Session) sessionControl.getMock();
SessionFactory factory = new SingleSessionFactory(session);
session.hasExternalTransactionController();
sessionControl.setReturnValue(false, 1);
sessionControl.replay();
Session boundSession = SessionFactoryUtils.getSession(factory, true);
assertTrue(session == boundSession);
SessionHolder holder = (SessionHolder) TransactionSynchronizationManager.getResource(factory);
assertTrue(holder == null);
TransactionSynchronizationManager.initSynchronization();
boundSession = SessionFactoryUtils.getSession(factory, true);
assertTrue(session == boundSession);
assertTrue(TransactionSynchronizationManager.getSynchronizations().size() == 1);
assertTrue(TransactionSynchronizationManager.hasResource(factory));
assertTrue(session == ((SessionHolder) TransactionSynchronizationManager.getResource(factory)).getSession());
TransactionSynchronizationManager.clearSynchronization();
TransactionSynchronizationManager.unbindResource(factory);
}
public void testNoSessionBoundAllowAndNoInit() {
MockControl sessionControl = MockControl.createControl(Session.class);
Session session = (Session) sessionControl.getMock();
SessionFactory factory = new SingleSessionFactory(session);
session.hasExternalTransactionController();
sessionControl.setReturnValue(false, 2);
sessionControl.replay();
Session boundSession = SessionFactoryUtils.getSession(factory, true);
assertTrue(session == boundSession);
SessionHolder holder = (SessionHolder) TransactionSynchronizationManager.getResource(factory);
assertTrue(holder == null);
boundSession = SessionFactoryUtils.getSession(factory, true);
assertTrue(session == boundSession);
assertFalse(TransactionSynchronizationManager.hasResource(factory));
}
}

98
org.springframework.testsuite/src/test/java/org/springframework/orm/toplink/TopLinkInterceptorTests.java
Unescape View File

@ -1,98 +0,0 @@ @@ -1,98 +0,0 @@
/*
* Created on Mar 20, 2005
*
*/
package org.springframework.orm.toplink;
import junit.framework.TestCase;
import org.aopalliance.intercept.MethodInvocation;
import org.easymock.MockControl;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import oracle.toplink.sessions.Session;
/**
* @author Juergen Hoeller
* @author <a href="mailto:james.x.clark@oracle.com">James Clark</a>
* @since 28.04.2005
*/
public class TopLinkInterceptorTests extends TestCase {
public void testInterceptorWithNoSessionBoundAndNoSynchronizations() throws Throwable {
MockControl sessionControl = MockControl.createControl(Session.class);
Session session = (Session) sessionControl.getMock();
MockControl methodInvocationControl = MockControl.createControl(MethodInvocation.class);
MethodInvocation methodInvocation = (MethodInvocation) methodInvocationControl.getMock();
SessionFactory factory = new SingleSessionFactory(session);
TopLinkInterceptor interceptor = new TopLinkInterceptor();
interceptor.setSessionFactory(factory);
methodInvocation.proceed();
methodInvocationControl.setReturnValue(null, 1);
session.release();
sessionControl.setVoidCallable(1);
methodInvocationControl.replay();
sessionControl.replay();
try {
interceptor.invoke(methodInvocation);
}
catch (Throwable t) {
System.out.println(t);
t.printStackTrace();
fail();
}
assertFalse(TransactionSynchronizationManager.hasResource(factory));
sessionControl.verify();
methodInvocationControl.verify();
sessionControl.verify();
}
public void testInterceptorWithNoSessionBoundAndSynchronizationsActive() {
MockControl sessionControl = MockControl.createControl(Session.class);
Session session = (Session) sessionControl.getMock();
MockControl methodInvocationControl = MockControl.createControl(MethodInvocation.class);
MethodInvocation methodInvocation = (MethodInvocation) methodInvocationControl.getMock();
SessionFactory factory = new SingleSessionFactory(session);
TopLinkInterceptor interceptor = new TopLinkInterceptor();
interceptor.setSessionFactory(factory);
try {
methodInvocation.proceed();
}
catch (Throwable e) {
fail();
}
methodInvocationControl.setReturnValue(null, 1);
methodInvocationControl.replay();
sessionControl.replay();
TransactionSynchronizationManager.initSynchronization();
try {
interceptor.invoke(methodInvocation);
}
catch (Throwable t) {
fail();
}
assertTrue(TransactionSynchronizationManager.hasResource(factory));
assertTrue(TransactionSynchronizationManager.getSynchronizations().size() == 1);
TransactionSynchronizationManager.clearSynchronization();
TransactionSynchronizationManager.unbindResource(factory);
sessionControl.verify();
methodInvocationControl.verify();
}
}

321
org.springframework.testsuite/src/test/java/org/springframework/orm/toplink/TopLinkJtaTransactionTests.java
Unescape View File

@ -1,321 +0,0 @@ @@ -1,321 +0,0 @@
/*
* Copyright 2002-2007 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.orm.toplink;
import java.util.ArrayList;
import java.util.List;
import javax.transaction.Status;
import javax.transaction.TransactionManager;
import javax.transaction.UserTransaction;
import junit.framework.TestCase;
import oracle.toplink.exceptions.TopLinkException;
import oracle.toplink.sessions.Session;
import org.easymock.MockControl;
import org.springframework.transaction.MockJtaTransaction;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.jta.JtaTransactionManager;
import org.springframework.transaction.support.TransactionCallback;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import org.springframework.transaction.support.TransactionTemplate;
/**
* @author Juergen Hoeller
* @author <a href="mailto:james.x.clark@oracle.com">James Clark</a>
* @since 28.04.2005
*/
public class TopLinkJtaTransactionTests extends TestCase {
public void testParticipatingJtaTransactionWithWithRequiresNew() throws Exception {
MockControl utControl = MockControl.createControl(UserTransaction.class);
UserTransaction ut = (UserTransaction) utControl.getMock();
MockControl tmControl = MockControl.createControl(TransactionManager.class);
TransactionManager tm = (TransactionManager) tmControl.getMock();
MockControl tx1Control = MockControl.createControl(javax.transaction.Transaction.class);
javax.transaction.Transaction tx1 = (javax.transaction.Transaction) tx1Control.getMock();
MockControl session1Control = MockControl.createControl(Session.class);
Session session1 = (Session) session1Control.getMock();
MockControl session2Control = MockControl.createControl(Session.class);
final Session session2 = (Session) session2Control.getMock();
final MockSessionFactory sf = new MockSessionFactory(session1);
ut.getStatus();
utControl.setReturnValue(Status.STATUS_NO_TRANSACTION, 1);
ut.getStatus();
utControl.setReturnValue(Status.STATUS_ACTIVE, 5);
ut.begin();
utControl.setVoidCallable(2);
tm.suspend();
tmControl.setReturnValue(tx1, 1);
tm.resume(tx1);
tmControl.setVoidCallable(1);
ut.commit();
utControl.setVoidCallable(2);
// session1.hasExternalTransactionController();
// session1Control.setReturnValue(true,1);
session1.release();
session1Control.setVoidCallable(1);
// session2.hasExternalTransactionController();
// session2Control.setReturnValue(true,1);
session2.release();
session2Control.setVoidCallable(1);
utControl.replay();
tmControl.replay();
session1Control.replay();
session2Control.replay();
JtaTransactionManager ptm = new JtaTransactionManager();
ptm.setUserTransaction(ut);
ptm.setTransactionManager(tm);
final TransactionTemplate tt = new TransactionTemplate(ptm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
tt.execute(new TransactionCallback() {
public Object doInTransaction(TransactionStatus status) {
SessionFactoryUtils.getSession(sf, true);
final SessionHolder holder = (SessionHolder) TransactionSynchronizationManager.getResource(sf);
assertTrue("Has thread session", holder != null);
sf.setSession(session2);
tt.execute(new TransactionCallback() {
public Object doInTransaction(TransactionStatus status) {
TopLinkTemplate ht = new TopLinkTemplate(sf);
return ht.executeFind(new TopLinkCallback() {
public Object doInTopLink(Session session) {
assertTrue("Not enclosing session", session != holder.getSession());
return null;
}
});
}
});
assertTrue("Same thread session as before",
holder.getSession() == SessionFactoryUtils.getSession(sf, false));
return null;
}
});
assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
utControl.verify();
tmControl.verify();
session1Control.verify();
session2Control.verify();
}
public void testJtaTransactionCommit() throws Exception {
doTestJtaTransactionCommit(Status.STATUS_NO_TRANSACTION);
}
public void testJtaTransactionCommitWithExisting() throws Exception {
doTestJtaTransactionCommit(Status.STATUS_ACTIVE);
}
private void doTestJtaTransactionCommit(int status) throws Exception {
MockControl utControl = MockControl.createControl(UserTransaction.class);
UserTransaction ut = (UserTransaction) utControl.getMock();
ut.getStatus();
utControl.setReturnValue(status, 1);
if (status == Status.STATUS_NO_TRANSACTION) {
ut.begin();
utControl.setVoidCallable(1);
ut.getStatus();
utControl.setReturnValue(Status.STATUS_ACTIVE, 2);
ut.commit();
utControl.setVoidCallable(1);
}
else {
ut.getStatus();
utControl.setReturnValue(status, 1);
}
utControl.replay();
final MockControl sessionControl = MockControl.createControl(Session.class);
final Session session = (Session) sessionControl.getMock();
final SessionFactory sf = new SingleSessionFactory(session);
sessionControl.replay();
JtaTransactionManager ptm = new JtaTransactionManager(ut);
TransactionTemplate tt = new TransactionTemplate(ptm);
final List l = new ArrayList();
l.add("test");
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
Object result = tt.execute(new TransactionCallback() {
public Object doInTransaction(TransactionStatus status) {
try {
assertTrue("JTA synchronizations active", TransactionSynchronizationManager.isSynchronizationActive());
assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
TopLinkTemplate ht = new TopLinkTemplate(sf);
List htl = ht.executeFind(new TopLinkCallback() {
public Object doInTopLink(Session sess) {
assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
assertEquals(session, sess);
return l;
}
});
ht = new TopLinkTemplate(sf);
htl = ht.executeFind(new TopLinkCallback() {
public Object doInTopLink(Session sess) {
assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
assertEquals(session, sess);
return l;
}
});
assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
sessionControl.verify();
sessionControl.reset();
try {
session.release();
sessionControl.setVoidCallable(1);
}
catch (TopLinkException e) {
}
sessionControl.replay();
return htl;
}
catch (Error err) {
err.printStackTrace();
throw err;
}
}
});
assertTrue("Correct result list", result == l);
assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
utControl.verify();
sessionControl.verify();
}
public void testJtaTransactionCommitWithJtaTm() throws Exception {
doTestJtaTransactionCommitWithJtaTm(Status.STATUS_NO_TRANSACTION);
}
public void testJtaTransactionCommitWithJtaTmAndExisting() throws Exception {
doTestJtaTransactionCommitWithJtaTm(Status.STATUS_ACTIVE);
}
private void doTestJtaTransactionCommitWithJtaTm(int status) throws Exception {
MockControl utControl = MockControl.createControl(UserTransaction.class);
UserTransaction ut = (UserTransaction) utControl.getMock();
ut.getStatus();
utControl.setReturnValue(status, 1);
if (status == Status.STATUS_NO_TRANSACTION) {
ut.begin();
utControl.setVoidCallable(1);
ut.getStatus();
utControl.setReturnValue(Status.STATUS_ACTIVE, 2);
ut.commit();
utControl.setVoidCallable(1);
}
else {
ut.getStatus();
utControl.setReturnValue(status, 1);
}
MockControl tmControl = MockControl.createControl(TransactionManager.class);
TransactionManager tm = (TransactionManager) tmControl.getMock();
MockJtaTransaction transaction = new MockJtaTransaction();
tm.getStatus();
tmControl.setReturnValue(Status.STATUS_ACTIVE, 6);
tm.getTransaction();
tmControl.setReturnValue(transaction, 6);
final MockControl sessionControl = MockControl.createControl(Session.class);
final Session session = (Session) sessionControl.getMock();
final SessionFactory sf = new SingleSessionFactory(session);
utControl.replay();
tmControl.replay();
sessionControl.replay();
JtaTransactionManager ptm = new JtaTransactionManager(ut);
TransactionTemplate tt = new TransactionTemplate(ptm);
final List l = new ArrayList();
l.add("test");
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
Object result = tt.execute(new TransactionCallback() {
public Object doInTransaction(TransactionStatus status) {
try {
assertTrue("JTA synchronizations active", TransactionSynchronizationManager.isSynchronizationActive());
assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
TopLinkTemplate ht = new TopLinkTemplate(sf);
List htl = ht.executeFind(new TopLinkCallback() {
public Object doInTopLink(Session sess) {
assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
assertEquals(session, sess);
return l;
}
});
ht = new TopLinkTemplate(sf);
htl = ht.executeFind(new TopLinkCallback() {
public Object doInTopLink(Session sess) {
assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
assertEquals(session, sess);
return l;
}
});
assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
sessionControl.verify();
sessionControl.reset();
try {
session.release();
sessionControl.setVoidCallable(1);
}
catch (TopLinkException e) {
}
sessionControl.replay();
return htl;
}
catch (Error err) {
err.printStackTrace();
throw err;
}
}
});
assertTrue("Correct result list", result == l);
assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
utControl.verify();
sessionControl.verify();
}
protected void tearDown() {
assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty());
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
}
}

117
org.springframework.testsuite/src/test/java/org/springframework/orm/toplink/TopLinkTemplateTests.java
Unescape View File

@ -1,117 +0,0 @@ @@ -1,117 +0,0 @@
/*
* Created on Mar 20, 2005
*
*/
package org.springframework.orm.toplink;
import junit.framework.TestCase;
import oracle.toplink.exceptions.TopLinkException;
import oracle.toplink.sessions.Session;
import org.easymock.MockControl;
import org.springframework.transaction.support.TransactionSynchronizationManager;
/**
* @author Juergen Hoeller
* @author <a href="mailto:james.x.clark@oracle.com">James Clark</a>
* @since 28.04.2005
*/
public class TopLinkTemplateTests extends TestCase {
public void testTemplateNotAllowingCreate() {
MockControl sessionControl = MockControl.createControl(Session.class);
Session session = (Session) sessionControl.getMock();
SessionFactory factory = new SingleSessionFactory(session);
TopLinkTemplate template = new TopLinkTemplate();
template.setAllowCreate(false);
template.setSessionFactory(factory);
try {
template.execute(new TopLinkCallback() {
public Object doInTopLink(Session session) throws TopLinkException {
return null;
}
});
fail();
}
catch (Exception e) {
}
}
public void testTemplateWithCreate() {
MockControl sessionControl = MockControl.createControl(Session.class);
Session session = (Session) sessionControl.getMock();
SessionFactory factory = new SingleSessionFactory(session);
session.release();
sessionControl.setVoidCallable(1);
sessionControl.replay();
TopLinkTemplate template = new TopLinkTemplate();
template.setAllowCreate(true);
template.setSessionFactory(factory);
template.execute(new TopLinkCallback() {
public Object doInTopLink(Session session) throws TopLinkException {
assertTrue(session != null);
return null;
}
});
assertFalse(TransactionSynchronizationManager.hasResource(factory));
sessionControl.verify();
}
public void testTemplateWithExistingSessionAndNoCreate() {
MockControl sessionControl = MockControl.createControl(Session.class);
Session session = (Session) sessionControl.getMock();
SessionFactory factory = new SingleSessionFactory(session);
sessionControl.replay();
SessionHolder sessionHolder = new SessionHolder(factory.createSession());
TransactionSynchronizationManager.bindResource(factory, sessionHolder);
TopLinkTemplate template = new TopLinkTemplate();
template.setAllowCreate(false);
template.setSessionFactory(factory);
template.execute(new TopLinkCallback() {
public Object doInTopLink(Session session) throws TopLinkException {
assertTrue(session != null);
return null;
}
});
assertTrue(TransactionSynchronizationManager.hasResource(factory));
sessionControl.verify();
TransactionSynchronizationManager.unbindResource(factory);
}
public void testTemplateWithExistingSessionAndCreateAllowed() {
MockControl sessionControl = MockControl.createControl(Session.class);
Session session = (Session) sessionControl.getMock();
SessionFactory factory = new SingleSessionFactory(session);
sessionControl.replay();
SessionHolder sessionHolder = new SessionHolder(factory.createSession());
TransactionSynchronizationManager.bindResource(factory, sessionHolder);
TopLinkTemplate template = new TopLinkTemplate();
template.setAllowCreate(true);
template.setSessionFactory(factory);
template.execute(new TopLinkCallback() {
public Object doInTopLink(Session session) throws TopLinkException {
assertTrue(session != null);
return null;
}
});
assertTrue(TransactionSynchronizationManager.hasResource(factory));
sessionControl.verify();
TransactionSynchronizationManager.unbindResource(factory);
}
}

496
org.springframework.testsuite/src/test/java/org/springframework/orm/toplink/TopLinkTransactionManagerTests.java
Unescape View File

@ -1,496 +0,0 @@ @@ -1,496 +0,0 @@
/*
* Created on Mar 20, 2005
*
*/
package org.springframework.orm.toplink;
import java.util.ArrayList;
import java.util.List;
import junit.framework.TestCase;
import oracle.toplink.sessions.Session;
import oracle.toplink.sessions.UnitOfWork;
import org.easymock.MockControl;
import org.springframework.jdbc.support.SQLStateSQLExceptionTranslator;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.UnexpectedRollbackException;
import org.springframework.transaction.support.TransactionCallback;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import org.springframework.transaction.support.TransactionTemplate;
/**
* @author Juergen Hoeller
* @author <a href="mailto:james.x.clark@oracle.com">James Clark</a>
* @since 28.04.2005
*/
public class TopLinkTransactionManagerTests extends TestCase {
public void testTransactionCommit() {
MockControl sessionControl = MockControl.createControl(Session.class);
final Session session = (Session) sessionControl.getMock();
MockControl uowControl = MockControl.createControl(UnitOfWork.class);
UnitOfWork uow = (UnitOfWork) uowControl.getMock();
final SessionFactory sf = new MockSessionFactory(session);
// during commit, TM must get the active UnitOfWork
session.getActiveUnitOfWork();
sessionControl.setReturnValue(uow, 2);
uow.beginEarlyTransaction();
uowControl.setVoidCallable(1);
uow.commit();
uowControl.setVoidCallable();
// session should be released when it was bound explicitly by the TM
session.release();
sessionControl.setVoidCallable();
sessionControl.replay();
uowControl.replay();
TopLinkTransactionManager tm = new TopLinkTransactionManager();
tm.setJdbcExceptionTranslator(new SQLStateSQLExceptionTranslator());
tm.setSessionFactory(sf);
TransactionTemplate tt = new TransactionTemplate(tm);
tt.setIsolationLevel(TransactionDefinition.ISOLATION_SERIALIZABLE);
tt.setTimeout(10);
assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
Object result = tt.execute(new TransactionCallback() {
public Object doInTransaction(TransactionStatus status) {
assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
TopLinkTemplate template = new TopLinkTemplate(sf);
return template.execute(new TopLinkCallback() {
public Object doInTopLink(Session session) {
return null;
}
});
}
});
assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
sessionControl.verify();
uowControl.verify();
}
public void testTransactionRollback() {
MockControl sessionControl = MockControl.createControl(Session.class);
final Session session = (Session) sessionControl.getMock();
MockControl uowControl = MockControl.createControl(UnitOfWork.class);
UnitOfWork uow = (UnitOfWork) uowControl.getMock();
final SessionFactory sf = new MockSessionFactory(session);
session.getActiveUnitOfWork();
sessionControl.setReturnValue(uow, 1);
uow.beginEarlyTransaction();
uowControl.setVoidCallable(1);
session.release();
sessionControl.setVoidCallable(1);
sessionControl.replay();
uowControl.replay();
TopLinkTransactionManager tm = new TopLinkTransactionManager();
tm.setSessionFactory(sf);
tm.setJdbcExceptionTranslator(new SQLStateSQLExceptionTranslator());
TransactionTemplate tt = new TransactionTemplate(tm);
tt.setIsolationLevel(TransactionDefinition.ISOLATION_SERIALIZABLE);
tt.setTimeout(10);
assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
try {
Object result = tt.execute(new TransactionCallback() {
public Object doInTransaction(TransactionStatus status) {
assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
TopLinkTemplate template = new TopLinkTemplate(sf);
return template.execute(new TopLinkCallback() {
public Object doInTopLink(Session session) {
throw new RuntimeException("failure");
}
});
}
});
fail("Should have propagated RuntimeException");
}
catch (RuntimeException ex) {
assertTrue(ex.getMessage().equals("failure"));
}
assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
sessionControl.verify();
uowControl.verify();
}
public void testTransactionRollbackOnly() {
MockControl sessionControl = MockControl.createControl(Session.class);
final Session session = (Session) sessionControl.getMock();
final SessionFactory sf = new MockSessionFactory(session);
session.release();
sessionControl.setVoidCallable();
sessionControl.replay();
TopLinkTransactionManager tm = new TopLinkTransactionManager();
tm.setSessionFactory(sf);
tm.setLazyDatabaseTransaction(true);
tm.setJdbcExceptionTranslator(new SQLStateSQLExceptionTranslator());
TransactionTemplate tt = new TransactionTemplate(tm);
tt.setIsolationLevel(TransactionDefinition.ISOLATION_SERIALIZABLE);
tt.setTimeout(10);
assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
Object result = tt.execute(new TransactionCallback() {
public Object doInTransaction(TransactionStatus status) {
assertTrue("Has thread session",
TransactionSynchronizationManager.hasResource(sf));
TopLinkTemplate template = new TopLinkTemplate(sf);
template.execute(new TopLinkCallback() {
public Object doInTopLink(Session session) {
return null;
}
});
status.setRollbackOnly();
return null;
}
});
assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
sessionControl.verify();
}
public void testParticipatingTransactionWithCommit() {
MockControl sessionControl = MockControl.createControl(Session.class);
final Session session = (Session) sessionControl.getMock();
MockControl uowControl = MockControl.createControl(UnitOfWork.class);
UnitOfWork uow = (UnitOfWork) uowControl.getMock();
final SessionFactory sf = new MockSessionFactory(session);
session.getActiveUnitOfWork();
sessionControl.setReturnValue(uow, 2);
uow.beginEarlyTransaction();
uowControl.setVoidCallable(1);
uow.commit();
uowControl.setVoidCallable();
session.release();
sessionControl.setVoidCallable();
sessionControl.replay();
uowControl.replay();
PlatformTransactionManager tm = new TopLinkTransactionManager(sf);
final TransactionTemplate tt = new TransactionTemplate(tm);
Object result = tt.execute(new TransactionCallback() {
public Object doInTransaction(TransactionStatus status) {
return tt.execute(new TransactionCallback() {
public Object doInTransaction(TransactionStatus status) {
TopLinkTemplate ht = new TopLinkTemplate(sf);
return ht.executeFind(new TopLinkCallback() {
public Object doInTopLink(Session injectedSession) {
assertTrue(session == injectedSession);
return null;
}
});
}
});
}
});
sessionControl.verify();
uowControl.verify();
}
public void testParticipatingTransactionWithRollback() {
MockControl sessionControl = MockControl.createControl(Session.class);
final Session session = (Session) sessionControl.getMock();
final SessionFactory sf = new MockSessionFactory(session);
session.release();
sessionControl.setVoidCallable();
sessionControl.replay();
TopLinkTransactionManager tm = new TopLinkTransactionManager(sf);
tm.setLazyDatabaseTransaction(true);
final TransactionTemplate tt = new TransactionTemplate(tm);
try {
tt.execute(new TransactionCallback() {
public Object doInTransaction(TransactionStatus status) {
return tt.execute(new TransactionCallback() {
public Object doInTransaction(TransactionStatus status) {
TopLinkTemplate ht = new TopLinkTemplate(sf);
return ht.executeFind(new TopLinkCallback() {
public Object doInTopLink(Session session) {
throw new RuntimeException("application exception");
}
});
}
});
}
});
fail("Should not thrown RuntimeException");
}
catch (RuntimeException ex) {
assertTrue(ex.getMessage().equals("application exception"));
}
sessionControl.verify();
}
public void testParticipatingTransactionWithRollbackOnly() {
MockControl sessionControl = MockControl.createControl(Session.class);
final Session session = (Session) sessionControl.getMock();
final SessionFactory sf = new MockSessionFactory(session);
session.release();
sessionControl.setVoidCallable();
sessionControl.replay();
TopLinkTransactionManager tm = new TopLinkTransactionManager(sf);
tm.setLazyDatabaseTransaction(true);
final TransactionTemplate tt = new TransactionTemplate(tm);
try {
tt.execute(new TransactionCallback() {
public Object doInTransaction(TransactionStatus status) {
tt.execute(new TransactionCallback() {
public Object doInTransaction(TransactionStatus status) {
TopLinkTemplate ht = new TopLinkTemplate(sf);
ht.execute(new TopLinkCallback() {
public Object doInTopLink(Session session) {
return null;
}
});
status.setRollbackOnly();
return null;
}
});
return null;
}
});
fail("Should have thrown UnexpectedRollbackException");
}
catch (UnexpectedRollbackException ex) {
// expected
}
sessionControl.verify();
}
public void testParticipatingTransactionWithWithRequiresNew() {
MockControl session1Control = MockControl.createControl(Session.class);
final Session session1 = (Session) session1Control.getMock();
MockControl session2Control = MockControl.createControl(Session.class);
final Session session2 = (Session) session2Control.getMock();
MockControl uow1Control = MockControl.createControl(UnitOfWork.class);
UnitOfWork uow1 = (UnitOfWork) uow1Control.getMock();
MockControl uow2Control = MockControl.createControl(UnitOfWork.class);
UnitOfWork uow2 = (UnitOfWork) uow2Control.getMock();
final MockSessionFactory sf = new MockSessionFactory(session1);
session2.getActiveUnitOfWork();
session2Control.setReturnValue(uow2, 2);
uow2.beginEarlyTransaction();
uow2Control.setVoidCallable(1);
uow2.commit();
uow2Control.setVoidCallable();
session2.release();
session2Control.setVoidCallable();
session1.getActiveUnitOfWork();
session1Control.setReturnValue(uow1, 2);
uow1.beginEarlyTransaction();
uow1Control.setVoidCallable(1);
uow1.commit();
uow1Control.setVoidCallable();
session1.release();
session1Control.setVoidCallable();
session1Control.replay();
uow1Control.replay();
session2Control.replay();
uow2Control.replay();
PlatformTransactionManager tm = new TopLinkTransactionManager(sf);
final TransactionTemplate tt = new TransactionTemplate(tm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
tt.execute(new TransactionCallback() {
public Object doInTransaction(TransactionStatus status) {
final SessionHolder holder = (SessionHolder) TransactionSynchronizationManager.getResource(sf);
assertTrue("Has thread session", holder != null);
sf.setSession(session2);
tt.execute(new TransactionCallback() {
public Object doInTransaction(TransactionStatus status) {
TopLinkTemplate ht = new TopLinkTemplate(sf);
return ht.execute(new TopLinkCallback() {
public Object doInTopLink(Session session) {
assertTrue("Not enclosing session", session != holder.getSession());
return null;
}
});
}
});
assertTrue("Same thread session as before",
holder.getSession() == SessionFactoryUtils.getSession(sf, false));
return null;
}
});
assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
session1Control.verify();
session2Control.verify();
uow1Control.verify();
uow2Control.verify();
}
public void testParticipatingTransactionWithWithNotSupported() {
MockControl sessionControl = MockControl.createControl(Session.class);
final Session session = (Session) sessionControl.getMock();
MockControl uowControl = MockControl.createControl(UnitOfWork.class);
UnitOfWork uow = (UnitOfWork) uowControl.getMock();
final SessionFactory sf = new MockSessionFactory(session);
session.getActiveUnitOfWork();
sessionControl.setReturnValue(uow, 2);
uow.beginEarlyTransaction();
uowControl.setVoidCallable(1);
uow.commit();
uowControl.setVoidCallable();
session.release();
sessionControl.setVoidCallable(2);
sessionControl.replay();
uowControl.replay();
TopLinkTransactionManager tm = new TopLinkTransactionManager(sf);
final TransactionTemplate tt = new TransactionTemplate(tm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
tt.execute(new TransactionCallback() {
public Object doInTransaction(TransactionStatus status) {
SessionHolder holder = (SessionHolder) TransactionSynchronizationManager.getResource(sf);
assertTrue("Has thread session", holder != null);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NOT_SUPPORTED);
tt.execute(new TransactionCallback() {
public Object doInTransaction(TransactionStatus status) {
assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
TopLinkTemplate ht = new TopLinkTemplate(sf);
return ht.execute(new TopLinkCallback() {
public Object doInTopLink(Session session) {
return null;
}
});
}
});
assertTrue("Same thread session as before", holder.getSession() == SessionFactoryUtils.getSession(sf, false));
return null;
}
});
assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
sessionControl.verify();
uowControl.verify();
}
public void testTransactionWithPropagationSupports() {
MockControl sessionControl = MockControl.createControl(Session.class);
final Session session = (Session) sessionControl.getMock();
final SessionFactory sf = new MockSessionFactory(session);
// not a new transaction, won't start a new one
session.release();
sessionControl.setVoidCallable();
sessionControl.replay();
PlatformTransactionManager tm = new TopLinkTransactionManager(sf);
TransactionTemplate tt = new TransactionTemplate(tm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
tt.execute(new TransactionCallback() {
public Object doInTransaction(TransactionStatus status) {
assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
assertTrue("Is not new transaction", !status.isNewTransaction());
TopLinkTemplate ht = new TopLinkTemplate(sf);
ht.execute(new TopLinkCallback() {
public Object doInTopLink(Session session) {
return null;
}
});
assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
return null;
}
});
assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
sessionControl.verify();
}
public void testTransactionCommitWithReadOnly() {
MockControl sessionControl = MockControl.createControl(Session.class);
final Session session = (Session) sessionControl.getMock();
MockControl uowControl = MockControl.createControl(UnitOfWork.class);
UnitOfWork uow = (UnitOfWork) uowControl.getMock();
final SessionFactory sf = new MockSessionFactory(session);
session.release();
sessionControl.setVoidCallable();
sessionControl.replay();
uowControl.replay();
TopLinkTransactionManager tm = new TopLinkTransactionManager(sf);
TransactionTemplate tt = new TransactionTemplate(tm);
tt.setReadOnly(true);
final List l = new ArrayList();
l.add("test");
assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
Object result = tt.execute(new TransactionCallback() {
public Object doInTransaction(TransactionStatus status) {
assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
TopLinkTemplate ht = new TopLinkTemplate(sf);
return ht.executeFind(new TopLinkCallback() {
public Object doInTopLink(Session session) {
return l;
}
});
}
});
assertTrue("Correct result list", result == l);
assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
sessionControl.verify();
uowControl.verify();
}
protected void tearDown() {
assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty());
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
}
}
Write Preview
Loading…
Cancel
Save