Removed raw TopLink support
This commit is contained in:
Arjen Poutsma
parent
11a2e40d41
commit
59d3ebebc1
|
|
@ -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() {
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -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));
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -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();
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -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());
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
|
@ -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());
|
||||
}
|
||||
|
||||
}
|
||||
Loading…
Reference in New Issue