mirror of
https://github.com/spring-projects/spring-framework.git
synced 2026-09-20 20:59:07 +00:00
Drop JDO support
Issue: SPR-14130
This commit is contained in:
Juergen Hoeller
@@ -1,796 +0,0 @@
|
||||
/*
|
||||
* Copyright 2002-2013 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.jdo;
|
||||
|
||||
import java.sql.Connection;
|
||||
import java.sql.DatabaseMetaData;
|
||||
import java.sql.SQLException;
|
||||
import java.sql.Savepoint;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import javax.jdo.Constants;
|
||||
import javax.jdo.JDOFatalDataStoreException;
|
||||
import javax.jdo.PersistenceManager;
|
||||
import javax.jdo.PersistenceManagerFactory;
|
||||
import javax.jdo.Transaction;
|
||||
import javax.sql.DataSource;
|
||||
import javax.transaction.Status;
|
||||
import javax.transaction.TransactionManager;
|
||||
import javax.transaction.UserTransaction;
|
||||
|
||||
import org.junit.After;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
|
||||
import org.springframework.jdbc.datasource.ConnectionHandle;
|
||||
import org.springframework.jdbc.datasource.ConnectionHolder;
|
||||
import org.springframework.jdbc.datasource.SimpleConnectionHandle;
|
||||
import org.springframework.orm.jdo.support.SpringPersistenceManagerProxyBean;
|
||||
import org.springframework.orm.jdo.support.StandardPersistenceManagerProxyBean;
|
||||
import org.springframework.tests.transaction.MockJtaTransaction;
|
||||
import org.springframework.transaction.PlatformTransactionManager;
|
||||
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.TransactionCallbackWithoutResult;
|
||||
import org.springframework.transaction.support.TransactionSynchronizationManager;
|
||||
import org.springframework.transaction.support.TransactionTemplate;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
import static org.mockito.BDDMockito.*;
|
||||
|
||||
/**
|
||||
* @author Juergen Hoeller
|
||||
* @author Phillip Webb
|
||||
*/
|
||||
public class JdoTransactionManagerTests {
|
||||
|
||||
private PersistenceManagerFactory pmf;
|
||||
|
||||
private PersistenceManager pm;
|
||||
|
||||
private Transaction tx;
|
||||
|
||||
|
||||
@Before
|
||||
public void setUp() {
|
||||
pmf = mock(PersistenceManagerFactory.class);
|
||||
pm = mock(PersistenceManager.class);
|
||||
tx = mock(Transaction.class);
|
||||
}
|
||||
|
||||
@After
|
||||
public void tearDown() {
|
||||
assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty());
|
||||
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
|
||||
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
|
||||
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testTransactionCommit() {
|
||||
given(pmf.getPersistenceManager()).willReturn(pm);
|
||||
given(pmf.getPersistenceManagerProxy()).willReturn(pm);
|
||||
given(pm.currentTransaction()).willReturn(tx);
|
||||
|
||||
PlatformTransactionManager tm = new JdoTransactionManager(pmf);
|
||||
TransactionTemplate tt = new TransactionTemplate(tm);
|
||||
final List l = new ArrayList();
|
||||
l.add("test");
|
||||
assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(pmf));
|
||||
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
|
||||
|
||||
Object result = tt.execute(new TransactionCallback() {
|
||||
@Override
|
||||
public Object doInTransaction(TransactionStatus status) {
|
||||
assertTrue("Has thread pm", TransactionSynchronizationManager.hasResource(pmf));
|
||||
|
||||
TransactionAwarePersistenceManagerFactoryProxy proxyFactory =
|
||||
new TransactionAwarePersistenceManagerFactoryProxy();
|
||||
proxyFactory.setTargetPersistenceManagerFactory(pmf);
|
||||
PersistenceManagerFactory pmfProxy = proxyFactory.getObject();
|
||||
assertEquals(pm.toString(), pmfProxy.getPersistenceManager().toString());
|
||||
pmfProxy.getPersistenceManager().flush();
|
||||
pmfProxy.getPersistenceManager().close();
|
||||
|
||||
SpringPersistenceManagerProxyBean proxyBean = new SpringPersistenceManagerProxyBean();
|
||||
proxyBean.setPersistenceManagerFactory(pmf);
|
||||
proxyBean.afterPropertiesSet();
|
||||
PersistenceManager pmProxy = proxyBean.getObject();
|
||||
assertSame(pmf, pmProxy.getPersistenceManagerFactory());
|
||||
pmProxy.flush();
|
||||
pmProxy.close();
|
||||
|
||||
StandardPersistenceManagerProxyBean stdProxyBean = new StandardPersistenceManagerProxyBean();
|
||||
stdProxyBean.setPersistenceManagerFactory(pmf);
|
||||
PersistenceManager stdPmProxy = stdProxyBean.getObject();
|
||||
stdPmProxy.flush();
|
||||
|
||||
PersistenceManagerFactoryUtils.getPersistenceManager(pmf, true).flush();
|
||||
return l;
|
||||
}
|
||||
});
|
||||
assertTrue("Correct result list", result == l);
|
||||
|
||||
assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(pmf));
|
||||
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
|
||||
|
||||
verify(pm, times(4)).flush();
|
||||
verify(pm).close();
|
||||
verify(tx).begin();
|
||||
verify(tx).commit();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testTransactionRollback() {
|
||||
given(pmf.getPersistenceManager()).willReturn(pm);
|
||||
given(pm.currentTransaction()).willReturn(tx);
|
||||
given(tx.isActive()).willReturn(true);
|
||||
|
||||
PlatformTransactionManager tm = new JdoTransactionManager(pmf);
|
||||
TransactionTemplate tt = new TransactionTemplate(tm);
|
||||
assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(pmf));
|
||||
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
|
||||
|
||||
try {
|
||||
tt.execute(new TransactionCallback() {
|
||||
@Override
|
||||
public Object doInTransaction(TransactionStatus status) {
|
||||
assertTrue("Has thread pm", TransactionSynchronizationManager.hasResource(pmf));
|
||||
PersistenceManagerFactoryUtils.getPersistenceManager(pmf, true);
|
||||
throw new RuntimeException("application exception");
|
||||
}
|
||||
});
|
||||
fail("Should have thrown RuntimeException");
|
||||
}
|
||||
catch (RuntimeException ex) {
|
||||
// expected
|
||||
}
|
||||
|
||||
assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(pmf));
|
||||
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
|
||||
|
||||
verify(pm).close();
|
||||
verify(tx).begin();
|
||||
verify(tx).rollback();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testTransactionRollbackWithAlreadyRolledBack() {
|
||||
given(pmf.getPersistenceManager()).willReturn(pm);
|
||||
given(pm.currentTransaction()).willReturn(tx);
|
||||
|
||||
PlatformTransactionManager tm = new JdoTransactionManager(pmf);
|
||||
TransactionTemplate tt = new TransactionTemplate(tm);
|
||||
assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(pmf));
|
||||
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
|
||||
|
||||
try {
|
||||
tt.execute(new TransactionCallback() {
|
||||
@Override
|
||||
public Object doInTransaction(TransactionStatus status) {
|
||||
assertTrue("Has thread pm", TransactionSynchronizationManager.hasResource(pmf));
|
||||
PersistenceManagerFactoryUtils.getPersistenceManager(pmf, true);
|
||||
throw new RuntimeException("application exception");
|
||||
}
|
||||
});
|
||||
fail("Should have thrown RuntimeException");
|
||||
}
|
||||
catch (RuntimeException ex) {
|
||||
// expected
|
||||
}
|
||||
|
||||
assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(pmf));
|
||||
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
|
||||
|
||||
verify(pm).close();
|
||||
verify(tx).begin();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testTransactionRollbackOnly() {
|
||||
given(pmf.getPersistenceManager()).willReturn(pm);
|
||||
given(pm.currentTransaction()).willReturn(tx);
|
||||
given(tx.isActive()).willReturn(true);
|
||||
|
||||
PlatformTransactionManager tm = new JdoTransactionManager(pmf);
|
||||
TransactionTemplate tt = new TransactionTemplate(tm);
|
||||
assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(pmf));
|
||||
|
||||
tt.execute(new TransactionCallback() {
|
||||
@Override
|
||||
public Object doInTransaction(TransactionStatus status) {
|
||||
assertTrue("Has thread pm", TransactionSynchronizationManager.hasResource(pmf));
|
||||
PersistenceManagerFactoryUtils.getPersistenceManager(pmf, true).flush();
|
||||
status.setRollbackOnly();
|
||||
return null;
|
||||
}
|
||||
});
|
||||
|
||||
assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(pmf));
|
||||
|
||||
verify(pm).flush();
|
||||
verify(pm).close();
|
||||
verify(tx).begin();
|
||||
verify(tx).rollback();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testParticipatingTransactionWithCommit() {
|
||||
given(pmf.getPersistenceManager()).willReturn(pm);
|
||||
given(pm.currentTransaction()).willReturn(tx);
|
||||
given(tx.isActive()).willReturn(true);
|
||||
|
||||
PlatformTransactionManager tm = new JdoTransactionManager(pmf);
|
||||
final TransactionTemplate tt = new TransactionTemplate(tm);
|
||||
final List l = new ArrayList();
|
||||
l.add("test");
|
||||
|
||||
Object result = tt.execute(new TransactionCallback() {
|
||||
@Override
|
||||
public Object doInTransaction(TransactionStatus status) {
|
||||
|
||||
return tt.execute(new TransactionCallback() {
|
||||
@Override
|
||||
public Object doInTransaction(TransactionStatus status) {
|
||||
PersistenceManagerFactoryUtils.getPersistenceManager(pmf, true).flush();
|
||||
return l;
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
assertTrue("Correct result list", result == l);
|
||||
|
||||
verify(pm).flush();
|
||||
verify(pm).close();
|
||||
verify(tx).begin();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testParticipatingTransactionWithRollback() {
|
||||
given(pmf.getPersistenceManager()).willReturn(pm);
|
||||
given(pm.currentTransaction()).willReturn(tx);
|
||||
given(tx.isActive()).willReturn(true);
|
||||
|
||||
PlatformTransactionManager tm = new JdoTransactionManager(pmf);
|
||||
final TransactionTemplate tt = new TransactionTemplate(tm);
|
||||
try {
|
||||
tt.execute(new TransactionCallback() {
|
||||
@Override
|
||||
public Object doInTransaction(TransactionStatus status) {
|
||||
return tt.execute(new TransactionCallback() {
|
||||
@Override
|
||||
public Object doInTransaction(TransactionStatus status) {
|
||||
PersistenceManagerFactoryUtils.getPersistenceManager(pmf, true);
|
||||
throw new RuntimeException("application exception");
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
fail("Should have thrown RuntimeException");
|
||||
}
|
||||
catch (RuntimeException ex) {
|
||||
// expected
|
||||
}
|
||||
verify(pm).close();
|
||||
verify(tx).begin();
|
||||
verify(tx).setRollbackOnly();
|
||||
verify(tx).rollback();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testParticipatingTransactionWithRollbackOnly() {
|
||||
given(pmf.getPersistenceManager()).willReturn(pm);
|
||||
given(pm.currentTransaction()).willReturn(tx);
|
||||
given(tx.isActive()).willReturn(true);
|
||||
given(tx.getRollbackOnly()).willReturn(true);
|
||||
willThrow(new JDOFatalDataStoreException()).given(tx).commit();
|
||||
|
||||
PlatformTransactionManager tm = new JdoTransactionManager(pmf);
|
||||
final TransactionTemplate tt = new TransactionTemplate(tm);
|
||||
final List l = new ArrayList();
|
||||
l.add("test");
|
||||
|
||||
try {
|
||||
tt.execute(new TransactionCallback() {
|
||||
@Override
|
||||
public Object doInTransaction(TransactionStatus status) {
|
||||
return tt.execute(new TransactionCallback() {
|
||||
@Override
|
||||
public Object doInTransaction(TransactionStatus status) {
|
||||
PersistenceManagerFactoryUtils.getPersistenceManager(pmf, true).flush();
|
||||
status.setRollbackOnly();
|
||||
return null;
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
fail("Should have thrown JdoResourceFailureException");
|
||||
}
|
||||
catch (JdoResourceFailureException ex) {
|
||||
// expected
|
||||
}
|
||||
verify(pm).flush();
|
||||
verify(pm).close();
|
||||
verify(tx).begin();
|
||||
verify(tx).setRollbackOnly();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testParticipatingTransactionWithWithRequiresNew() {
|
||||
given(pmf.getPersistenceManager()).willReturn(pm);
|
||||
given(pm.currentTransaction()).willReturn(tx);
|
||||
given(tx.isActive()).willReturn(true);
|
||||
|
||||
PlatformTransactionManager tm = new JdoTransactionManager(pmf);
|
||||
final TransactionTemplate tt = new TransactionTemplate(tm);
|
||||
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
|
||||
final List l = new ArrayList();
|
||||
l.add("test");
|
||||
|
||||
Object result = tt.execute(new TransactionCallback() {
|
||||
@Override
|
||||
public Object doInTransaction(TransactionStatus status) {
|
||||
return tt.execute(new TransactionCallback() {
|
||||
@Override
|
||||
public Object doInTransaction(TransactionStatus status) {
|
||||
PersistenceManagerFactoryUtils.getPersistenceManager(pmf, true).flush();
|
||||
return l;
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
assertTrue("Correct result list", result == l);
|
||||
verify(tx, times(2)).begin();
|
||||
verify(tx, times(2)).commit();
|
||||
verify(pm).flush();
|
||||
verify(pm, times(2)).close();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testParticipatingTransactionWithWithRequiresNewAndPrebound() {
|
||||
given(pmf.getPersistenceManager()).willReturn(pm);
|
||||
given(pm.currentTransaction()).willReturn(tx);
|
||||
given(tx.isActive()).willReturn(true);
|
||||
|
||||
PlatformTransactionManager tm = new JdoTransactionManager(pmf);
|
||||
final TransactionTemplate tt = new TransactionTemplate(tm);
|
||||
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
|
||||
final List l = new ArrayList();
|
||||
l.add("test");
|
||||
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
|
||||
TransactionSynchronizationManager.bindResource(pmf, new PersistenceManagerHolder(pm));
|
||||
assertTrue("Has thread pm", TransactionSynchronizationManager.hasResource(pmf));
|
||||
|
||||
Object result = tt.execute(new TransactionCallback() {
|
||||
@Override
|
||||
public Object doInTransaction(TransactionStatus status) {
|
||||
PersistenceManagerFactoryUtils.getPersistenceManager(pmf, true);
|
||||
|
||||
return tt.execute(new TransactionCallback() {
|
||||
@Override
|
||||
public Object doInTransaction(TransactionStatus status) {
|
||||
PersistenceManagerFactoryUtils.getPersistenceManager(pmf, true).flush();
|
||||
return l;
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
assertTrue("Correct result list", result == l);
|
||||
|
||||
assertTrue("Has thread pm", TransactionSynchronizationManager.hasResource(pmf));
|
||||
TransactionSynchronizationManager.unbindResource(pmf);
|
||||
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
|
||||
|
||||
verify(tx, times(2)).begin();
|
||||
verify(tx, times(2)).commit();
|
||||
verify(pm).flush();
|
||||
verify(pm).close();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJtaTransactionCommit() throws Exception {
|
||||
UserTransaction ut = mock(UserTransaction.class);
|
||||
given(ut.getStatus()).willReturn(Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE);
|
||||
given(pmf.getPersistenceManager()).willReturn(pm);
|
||||
|
||||
JtaTransactionManager ptm = new JtaTransactionManager(ut);
|
||||
TransactionTemplate tt = new TransactionTemplate(ptm);
|
||||
final List l = new ArrayList();
|
||||
l.add("test");
|
||||
assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(pmf));
|
||||
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
|
||||
|
||||
Object result = tt.execute(new TransactionCallback() {
|
||||
@Override
|
||||
public Object doInTransaction(TransactionStatus status) {
|
||||
assertTrue("JTA synchronizations active", TransactionSynchronizationManager.isSynchronizationActive());
|
||||
assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(pmf));
|
||||
PersistenceManagerFactoryUtils.getPersistenceManager(pmf, true).flush();
|
||||
PersistenceManagerFactoryUtils.getPersistenceManager(pmf, true).flush();
|
||||
assertTrue("Has thread pm", TransactionSynchronizationManager.hasResource(pmf));
|
||||
return l;
|
||||
}
|
||||
});
|
||||
assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(pmf));
|
||||
assertTrue("Correct result list", result == l);
|
||||
|
||||
assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(pmf));
|
||||
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
|
||||
|
||||
verify(ut).begin();
|
||||
verify(ut).commit();
|
||||
verify(pm, times(2)).flush();
|
||||
verify(pm, times(2)).close();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testParticipatingJtaTransactionWithWithRequiresNewAndPrebound() throws Exception {
|
||||
final UserTransaction ut = mock(UserTransaction.class);
|
||||
final TransactionManager tm = mock(TransactionManager.class);
|
||||
|
||||
given(ut.getStatus()).willReturn(Status.STATUS_NO_TRANSACTION,
|
||||
Status.STATUS_ACTIVE, Status.STATUS_ACTIVE, Status.STATUS_ACTIVE,
|
||||
Status.STATUS_ACTIVE, Status.STATUS_ACTIVE);
|
||||
given(pmf.getPersistenceManager()).willReturn(pm);
|
||||
|
||||
JtaTransactionManager ptm = new JtaTransactionManager(ut, tm);
|
||||
final TransactionTemplate tt = new TransactionTemplate(ptm);
|
||||
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
|
||||
final List l = new ArrayList();
|
||||
l.add("test");
|
||||
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
|
||||
TransactionSynchronizationManager.bindResource(pmf, new PersistenceManagerHolder(pm));
|
||||
assertTrue("Has thread pm", TransactionSynchronizationManager.hasResource(pmf));
|
||||
|
||||
Object result = tt.execute(new TransactionCallback() {
|
||||
@Override
|
||||
public Object doInTransaction(TransactionStatus status) {
|
||||
try {
|
||||
MockJtaTransaction transaction = new MockJtaTransaction();
|
||||
given(tm.suspend()).willReturn(transaction);
|
||||
}
|
||||
catch (Exception ex) {
|
||||
}
|
||||
|
||||
PersistenceManagerFactoryUtils.getPersistenceManager(pmf, true);
|
||||
|
||||
return tt.execute(new TransactionCallback() {
|
||||
@Override
|
||||
public Object doInTransaction(TransactionStatus status) {
|
||||
PersistenceManagerFactoryUtils.getPersistenceManager(pmf, true).flush();
|
||||
return l;
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
assertTrue("Correct result list", result == l);
|
||||
|
||||
assertTrue("Has thread pm", TransactionSynchronizationManager.hasResource(pmf));
|
||||
TransactionSynchronizationManager.unbindResource(pmf);
|
||||
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
|
||||
|
||||
verify(ut, times(2)).begin();
|
||||
verify(pm).flush();
|
||||
verify(pm, times(2)).close();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testTransactionCommitWithPropagationSupports() {
|
||||
given(pmf.getPersistenceManager()).willReturn(pm);
|
||||
|
||||
PlatformTransactionManager tm = new JdoTransactionManager(pmf);
|
||||
TransactionTemplate tt = new TransactionTemplate(tm);
|
||||
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
|
||||
final List l = new ArrayList();
|
||||
l.add("test");
|
||||
assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(pmf));
|
||||
|
||||
Object result = tt.execute(new TransactionCallback() {
|
||||
@Override
|
||||
public Object doInTransaction(TransactionStatus status) {
|
||||
assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(pmf));
|
||||
assertTrue("Is not new transaction", !status.isNewTransaction());
|
||||
PersistenceManagerFactoryUtils.getPersistenceManager(pmf, true);
|
||||
return l;
|
||||
}
|
||||
});
|
||||
assertTrue("Correct result list", result == l);
|
||||
|
||||
assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(pmf));
|
||||
|
||||
verify(pm, times(2)).close();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsolationLevel() {
|
||||
given(pmf.getPersistenceManager()).willReturn(pm);
|
||||
given(pm.currentTransaction()).willReturn(tx);
|
||||
|
||||
PlatformTransactionManager tm = new JdoTransactionManager(pmf);
|
||||
TransactionTemplate tt = new TransactionTemplate(tm);
|
||||
tt.setIsolationLevel(TransactionDefinition.ISOLATION_SERIALIZABLE);
|
||||
tt.execute(new TransactionCallbackWithoutResult() {
|
||||
@Override
|
||||
protected void doInTransactionWithoutResult(TransactionStatus status) {
|
||||
}
|
||||
});
|
||||
verify(tx).setIsolationLevel(Constants.TX_SERIALIZABLE);
|
||||
verify(pm).close();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testTransactionCommitWithPrebound() {
|
||||
given(pm.currentTransaction()).willReturn(tx);
|
||||
|
||||
PlatformTransactionManager tm = new JdoTransactionManager(pmf);
|
||||
TransactionTemplate tt = new TransactionTemplate(tm);
|
||||
final List l = new ArrayList();
|
||||
l.add("test");
|
||||
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
|
||||
TransactionSynchronizationManager.bindResource(pmf, new PersistenceManagerHolder(pm));
|
||||
assertTrue("Has thread pm", TransactionSynchronizationManager.hasResource(pmf));
|
||||
|
||||
Object result = tt.execute(new TransactionCallback() {
|
||||
@Override
|
||||
public Object doInTransaction(TransactionStatus status) {
|
||||
assertTrue("Has thread pm", TransactionSynchronizationManager.hasResource(pmf));
|
||||
PersistenceManagerFactoryUtils.getPersistenceManager(pmf, true);
|
||||
return l;
|
||||
}
|
||||
});
|
||||
assertTrue("Correct result list", result == l);
|
||||
|
||||
assertTrue("Has thread pm", TransactionSynchronizationManager.hasResource(pmf));
|
||||
TransactionSynchronizationManager.unbindResource(pmf);
|
||||
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
|
||||
|
||||
verify(tx).begin();
|
||||
verify(tx).commit();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testTransactionCommitWithDataSource() throws SQLException {
|
||||
final DataSource ds = mock(DataSource.class);
|
||||
JdoDialect dialect = mock(JdoDialect.class);
|
||||
final Connection con = mock(Connection.class);
|
||||
ConnectionHandle conHandle = new SimpleConnectionHandle(con);
|
||||
|
||||
given(pmf.getPersistenceManager()).willReturn(pm);
|
||||
given(pm.currentTransaction()).willReturn(tx);
|
||||
TransactionTemplate tt = new TransactionTemplate();
|
||||
given(dialect.getJdbcConnection(pm, false)).willReturn(conHandle);
|
||||
|
||||
JdoTransactionManager tm = new JdoTransactionManager();
|
||||
tm.setPersistenceManagerFactory(pmf);
|
||||
tm.setDataSource(ds);
|
||||
tm.setJdoDialect(dialect);
|
||||
tt.setTransactionManager(tm);
|
||||
final List l = new ArrayList();
|
||||
l.add("test");
|
||||
assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(pmf));
|
||||
|
||||
Object result = tt.execute(new TransactionCallback() {
|
||||
@Override
|
||||
public Object doInTransaction(TransactionStatus status) {
|
||||
assertTrue("Has thread pm", TransactionSynchronizationManager.hasResource(pmf));
|
||||
assertTrue("Has thread con", TransactionSynchronizationManager.hasResource(ds));
|
||||
PersistenceManagerFactoryUtils.getPersistenceManager(pmf, true);
|
||||
return l;
|
||||
}
|
||||
});
|
||||
assertTrue("Correct result list", result == l);
|
||||
|
||||
assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(pmf));
|
||||
assertTrue("Hasn't thread con", !TransactionSynchronizationManager.hasResource(ds));
|
||||
|
||||
verify(pm).close();
|
||||
verify(dialect).beginTransaction(tx, tt);
|
||||
verify(dialect).releaseJdbcConnection(conHandle, pm);
|
||||
verify(dialect).cleanupTransaction(null);
|
||||
verify(tx).commit();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testTransactionCommitWithAutoDetectedDataSource() throws SQLException {
|
||||
final DataSource ds = mock(DataSource.class);
|
||||
JdoDialect dialect = mock(JdoDialect.class);
|
||||
final Connection con = mock(Connection.class);
|
||||
ConnectionHandle conHandle = new SimpleConnectionHandle(con);
|
||||
|
||||
given(pmf.getConnectionFactory()).willReturn(ds);
|
||||
given(pmf.getPersistenceManager()).willReturn(pm);
|
||||
given(pm.currentTransaction()).willReturn(tx);
|
||||
TransactionTemplate tt = new TransactionTemplate();
|
||||
given(dialect.getJdbcConnection(pm, false)).willReturn(conHandle);
|
||||
|
||||
JdoTransactionManager tm = new JdoTransactionManager();
|
||||
tm.setPersistenceManagerFactory(pmf);
|
||||
tm.setJdoDialect(dialect);
|
||||
tm.afterPropertiesSet();
|
||||
tt.setTransactionManager(tm);
|
||||
final List l = new ArrayList();
|
||||
l.add("test");
|
||||
assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(pmf));
|
||||
|
||||
Object result = tt.execute(new TransactionCallback() {
|
||||
@Override
|
||||
public Object doInTransaction(TransactionStatus status) {
|
||||
assertTrue("Has thread pm", TransactionSynchronizationManager.hasResource(pmf));
|
||||
assertTrue("Has thread con", TransactionSynchronizationManager.hasResource(ds));
|
||||
PersistenceManagerFactoryUtils.getPersistenceManager(pmf, true);
|
||||
return l;
|
||||
}
|
||||
});
|
||||
assertTrue("Correct result list", result == l);
|
||||
|
||||
assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(pmf));
|
||||
assertTrue("Hasn't thread con", !TransactionSynchronizationManager.hasResource(ds));
|
||||
|
||||
verify(pm).close();
|
||||
verify(dialect).beginTransaction(tx, tt);
|
||||
verify(dialect).releaseJdbcConnection(conHandle, pm);
|
||||
verify(dialect).cleanupTransaction(null);
|
||||
verify(tx).commit();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testTransactionCommitWithAutoDetectedDataSourceAndNoConnection() throws SQLException {
|
||||
final DataSource ds = mock(DataSource.class);
|
||||
final JdoDialect dialect = mock(JdoDialect.class);
|
||||
|
||||
given(pmf.getConnectionFactory()).willReturn(ds);
|
||||
given(pmf.getPersistenceManager()).willReturn(pm);
|
||||
given(pm.currentTransaction()).willReturn(tx);
|
||||
TransactionTemplate tt = new TransactionTemplate();
|
||||
given(dialect.getJdbcConnection(pm, false)).willReturn(null);
|
||||
|
||||
JdoTransactionManager tm = new JdoTransactionManager();
|
||||
tm.setPersistenceManagerFactory(pmf);
|
||||
tm.setJdoDialect(dialect);
|
||||
tm.afterPropertiesSet();
|
||||
tt.setTransactionManager(tm);
|
||||
final List l = new ArrayList();
|
||||
l.add("test");
|
||||
assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(pmf));
|
||||
|
||||
Object result = tt.execute(new TransactionCallback() {
|
||||
@Override
|
||||
public Object doInTransaction(TransactionStatus status) {
|
||||
assertTrue("Has thread pm", TransactionSynchronizationManager.hasResource(pmf));
|
||||
assertTrue("Hasn't thread con", !TransactionSynchronizationManager.hasResource(ds));
|
||||
PersistenceManagerFactoryUtils.getPersistenceManager(pmf, true).flush();
|
||||
return l;
|
||||
}
|
||||
});
|
||||
assertTrue("Correct result list", result == l);
|
||||
|
||||
assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(pmf));
|
||||
assertTrue("Hasn't thread con", !TransactionSynchronizationManager.hasResource(ds));
|
||||
|
||||
verify(pm).flush();
|
||||
verify(pm).close();
|
||||
verify(dialect).beginTransaction(tx, tt);
|
||||
verify(dialect).cleanupTransaction(null);
|
||||
verify(tx).commit();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testExistingTransactionWithPropagationNestedAndRollback() throws SQLException {
|
||||
doTestExistingTransactionWithPropagationNestedAndRollback(false);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testExistingTransactionWithManualSavepointAndRollback() throws SQLException {
|
||||
doTestExistingTransactionWithPropagationNestedAndRollback(true);
|
||||
}
|
||||
|
||||
private void doTestExistingTransactionWithPropagationNestedAndRollback(final boolean manualSavepoint)
|
||||
throws SQLException {
|
||||
|
||||
final DataSource ds = mock(DataSource.class);
|
||||
JdoDialect dialect = mock(JdoDialect.class);
|
||||
final Connection con = mock(Connection.class);
|
||||
DatabaseMetaData md = mock(DatabaseMetaData.class);
|
||||
Savepoint sp = mock(Savepoint.class);
|
||||
|
||||
given(pmf.getPersistenceManager()).willReturn(pm);
|
||||
given(pm.currentTransaction()).willReturn(tx);
|
||||
given(md.supportsSavepoints()).willReturn(true);
|
||||
given(con.getMetaData()).willReturn(md);
|
||||
given(con.setSavepoint(ConnectionHolder.SAVEPOINT_NAME_PREFIX + 1)).willReturn(sp);
|
||||
final TransactionTemplate tt = new TransactionTemplate();
|
||||
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
|
||||
ConnectionHandle conHandle = new SimpleConnectionHandle(con);
|
||||
given(dialect.getJdbcConnection(pm, false)).willReturn(conHandle);
|
||||
given(tx.isActive()).willReturn(!manualSavepoint);
|
||||
|
||||
JdoTransactionManager tm = new JdoTransactionManager();
|
||||
tm.setNestedTransactionAllowed(true);
|
||||
tm.setPersistenceManagerFactory(pmf);
|
||||
tm.setDataSource(ds);
|
||||
tm.setJdoDialect(dialect);
|
||||
tt.setTransactionManager(tm);
|
||||
final List l = new ArrayList();
|
||||
l.add("test");
|
||||
assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(pmf));
|
||||
|
||||
Object result = tt.execute(new TransactionCallback() {
|
||||
@Override
|
||||
public Object doInTransaction(TransactionStatus status) {
|
||||
assertTrue("Has thread pm", TransactionSynchronizationManager.hasResource(pmf));
|
||||
assertTrue("Has thread con", TransactionSynchronizationManager.hasResource(ds));
|
||||
if (manualSavepoint) {
|
||||
Object savepoint = status.createSavepoint();
|
||||
status.rollbackToSavepoint(savepoint);
|
||||
}
|
||||
else {
|
||||
tt.execute(new TransactionCallbackWithoutResult() {
|
||||
@Override
|
||||
protected void doInTransactionWithoutResult(TransactionStatus status) {
|
||||
assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(pmf));
|
||||
assertTrue("Has thread connection", TransactionSynchronizationManager.hasResource(ds));
|
||||
status.setRollbackOnly();
|
||||
}
|
||||
});
|
||||
}
|
||||
PersistenceManagerFactoryUtils.getPersistenceManager(pmf, true).flush();
|
||||
return l;
|
||||
}
|
||||
});
|
||||
assertTrue("Correct result list", result == l);
|
||||
|
||||
assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(pmf));
|
||||
assertTrue("Hasn't thread con", !TransactionSynchronizationManager.hasResource(ds));
|
||||
verify(pm).flush();
|
||||
verify(pm).close();
|
||||
verify(con).setSavepoint(ConnectionHolder.SAVEPOINT_NAME_PREFIX + 1);
|
||||
verify(con).rollback(sp);
|
||||
verify(dialect).beginTransaction(tx, tt);
|
||||
verify(dialect).releaseJdbcConnection(conHandle, pm);
|
||||
verify(dialect).cleanupTransaction(null);
|
||||
verify(tx).commit();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testTransactionFlush() {
|
||||
given(pmf.getPersistenceManager()).willReturn(pm);
|
||||
given(pm.currentTransaction()).willReturn(tx);
|
||||
|
||||
PlatformTransactionManager tm = new JdoTransactionManager(pmf);
|
||||
TransactionTemplate tt = new TransactionTemplate(tm);
|
||||
assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(pmf));
|
||||
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
|
||||
|
||||
tt.execute(new TransactionCallbackWithoutResult() {
|
||||
@Override
|
||||
public void doInTransactionWithoutResult(TransactionStatus status) {
|
||||
assertTrue("Has thread pm", TransactionSynchronizationManager.hasResource(pmf));
|
||||
status.flush();
|
||||
}
|
||||
});
|
||||
|
||||
assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(pmf));
|
||||
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
|
||||
verify(pm).flush();
|
||||
verify(pm).close();
|
||||
verify(tx).begin();
|
||||
verify(tx).commit();
|
||||
}
|
||||
|
||||
}
|
||||
-159
@@ -1,159 +0,0 @@
|
||||
/*
|
||||
* Copyright 2002-2013 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.jdo;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.util.Map;
|
||||
import java.util.Properties;
|
||||
import javax.jdo.JDOFatalUserException;
|
||||
import javax.jdo.PersistenceManagerFactory;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import org.springframework.core.io.ClassPathResource;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
import static org.mockito.BDDMockito.*;
|
||||
|
||||
/**
|
||||
* @author Juergen Hoeller
|
||||
* @author Phillip Webb
|
||||
*/
|
||||
public class LocalPersistenceManagerFactoryTests {
|
||||
|
||||
@Test
|
||||
public void testLocalPersistenceManagerFactoryBean() throws IOException {
|
||||
final PersistenceManagerFactory pmf = mock(PersistenceManagerFactory.class);
|
||||
LocalPersistenceManagerFactoryBean pmfb = new LocalPersistenceManagerFactoryBean() {
|
||||
@Override
|
||||
protected PersistenceManagerFactory newPersistenceManagerFactory(Map props) {
|
||||
return pmf;
|
||||
}
|
||||
};
|
||||
pmfb.setJdoProperties(new Properties());
|
||||
pmfb.afterPropertiesSet();
|
||||
assertSame(pmf, pmfb.getObject());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testLocalPersistenceManagerFactoryBeanWithInvalidSettings() throws IOException {
|
||||
LocalPersistenceManagerFactoryBean pmfb = new LocalPersistenceManagerFactoryBean();
|
||||
try {
|
||||
pmfb.afterPropertiesSet();
|
||||
fail("Should have thrown JDOFatalUserException");
|
||||
}
|
||||
catch (JDOFatalUserException ex) {
|
||||
// expected
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testLocalPersistenceManagerFactoryBeanWithIncompleteProperties() throws IOException {
|
||||
LocalPersistenceManagerFactoryBean pmfb = new LocalPersistenceManagerFactoryBean();
|
||||
Properties props = new Properties();
|
||||
props.setProperty("myKey", "myValue");
|
||||
pmfb.setJdoProperties(props);
|
||||
try {
|
||||
pmfb.afterPropertiesSet();
|
||||
fail("Should have thrown JDOFatalUserException");
|
||||
}
|
||||
catch (JDOFatalUserException ex) {
|
||||
// expected
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testLocalPersistenceManagerFactoryBeanWithInvalidProperty() throws IOException {
|
||||
LocalPersistenceManagerFactoryBean pmfb = new LocalPersistenceManagerFactoryBean() {
|
||||
@Override
|
||||
protected PersistenceManagerFactory newPersistenceManagerFactory(Map props) {
|
||||
throw new IllegalArgumentException((String) props.get("myKey"));
|
||||
}
|
||||
};
|
||||
Properties props = new Properties();
|
||||
props.setProperty("myKey", "myValue");
|
||||
pmfb.setJdoProperties(props);
|
||||
try {
|
||||
pmfb.afterPropertiesSet();
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
}
|
||||
catch (IllegalArgumentException ex) {
|
||||
// expected
|
||||
assertTrue("Correct exception", "myValue".equals(ex.getMessage()));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testLocalPersistenceManagerFactoryBeanWithFile() throws IOException {
|
||||
LocalPersistenceManagerFactoryBean pmfb = new LocalPersistenceManagerFactoryBean() {
|
||||
@Override
|
||||
protected PersistenceManagerFactory newPersistenceManagerFactory(Map props) {
|
||||
throw new IllegalArgumentException((String) props.get("myKey"));
|
||||
}
|
||||
};
|
||||
pmfb.setConfigLocation(new ClassPathResource("test.properties", getClass()));
|
||||
try {
|
||||
pmfb.afterPropertiesSet();
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
}
|
||||
catch (IllegalArgumentException ex) {
|
||||
// expected
|
||||
assertTrue("Correct exception", "myValue".equals(ex.getMessage()));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testLocalPersistenceManagerFactoryBeanWithName() throws IOException {
|
||||
LocalPersistenceManagerFactoryBean pmfb = new LocalPersistenceManagerFactoryBean() {
|
||||
@Override
|
||||
protected PersistenceManagerFactory newPersistenceManagerFactory(String name) {
|
||||
throw new IllegalArgumentException(name);
|
||||
}
|
||||
};
|
||||
pmfb.setPersistenceManagerFactoryName("myName");
|
||||
try {
|
||||
pmfb.afterPropertiesSet();
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
}
|
||||
catch (IllegalArgumentException ex) {
|
||||
// expected
|
||||
assertTrue("Correct exception", "myName".equals(ex.getMessage()));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testLocalPersistenceManagerFactoryBeanWithNameAndProperties() throws IOException {
|
||||
LocalPersistenceManagerFactoryBean pmfb = new LocalPersistenceManagerFactoryBean() {
|
||||
@Override
|
||||
protected PersistenceManagerFactory newPersistenceManagerFactory(String name) {
|
||||
throw new IllegalArgumentException(name);
|
||||
}
|
||||
};
|
||||
pmfb.setPersistenceManagerFactoryName("myName");
|
||||
pmfb.getJdoPropertyMap().put("myKey", "myValue");
|
||||
try {
|
||||
pmfb.afterPropertiesSet();
|
||||
fail("Should have thrown IllegalStateException");
|
||||
}
|
||||
catch (IllegalStateException ex) {
|
||||
// expected
|
||||
assertTrue(ex.getMessage().indexOf("persistenceManagerFactoryName") != -1);
|
||||
assertTrue(ex.getMessage().indexOf("jdoProp") != -1);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
-148
@@ -1,148 +0,0 @@
|
||||
/*
|
||||
* Copyright 2002-2013 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.jdo.support;
|
||||
|
||||
import java.io.IOException;
|
||||
import javax.jdo.PersistenceManager;
|
||||
import javax.jdo.PersistenceManagerFactory;
|
||||
import javax.servlet.FilterChain;
|
||||
import javax.servlet.ServletException;
|
||||
import javax.servlet.ServletRequest;
|
||||
import javax.servlet.ServletResponse;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import org.springframework.mock.web.test.MockFilterConfig;
|
||||
import org.springframework.mock.web.test.MockHttpServletRequest;
|
||||
import org.springframework.mock.web.test.MockHttpServletResponse;
|
||||
import org.springframework.mock.web.test.MockServletContext;
|
||||
import org.springframework.mock.web.test.PassThroughFilterChain;
|
||||
import org.springframework.transaction.support.TransactionSynchronizationManager;
|
||||
import org.springframework.web.context.WebApplicationContext;
|
||||
import org.springframework.web.context.request.ServletWebRequest;
|
||||
import org.springframework.web.context.support.StaticWebApplicationContext;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
import static org.mockito.BDDMockito.*;
|
||||
|
||||
/**
|
||||
* @author Juergen Hoeller
|
||||
* @author Chris Beams
|
||||
* @author Phillip Webb
|
||||
* @since 15.06.2004
|
||||
*/
|
||||
public class OpenPersistenceManagerInViewTests {
|
||||
|
||||
@Test
|
||||
public void testOpenPersistenceManagerInViewInterceptor() throws Exception {
|
||||
PersistenceManagerFactory pmf = mock(PersistenceManagerFactory.class);
|
||||
PersistenceManager pm = mock(PersistenceManager.class);
|
||||
|
||||
OpenPersistenceManagerInViewInterceptor interceptor = new OpenPersistenceManagerInViewInterceptor();
|
||||
interceptor.setPersistenceManagerFactory(pmf);
|
||||
|
||||
MockServletContext sc = new MockServletContext();
|
||||
MockHttpServletRequest request = new MockHttpServletRequest(sc);
|
||||
|
||||
given(pmf.getPersistenceManager()).willReturn(pm);
|
||||
interceptor.preHandle(new ServletWebRequest(request));
|
||||
assertTrue(TransactionSynchronizationManager.hasResource(pmf));
|
||||
|
||||
// check that further invocations simply participate
|
||||
interceptor.preHandle(new ServletWebRequest(request));
|
||||
|
||||
interceptor.preHandle(new ServletWebRequest(request));
|
||||
interceptor.postHandle(new ServletWebRequest(request), null);
|
||||
interceptor.afterCompletion(new ServletWebRequest(request), null);
|
||||
|
||||
interceptor.postHandle(new ServletWebRequest(request), null);
|
||||
interceptor.afterCompletion(new ServletWebRequest(request), null);
|
||||
|
||||
interceptor.preHandle(new ServletWebRequest(request));
|
||||
interceptor.postHandle(new ServletWebRequest(request), null);
|
||||
interceptor.afterCompletion(new ServletWebRequest(request), null);
|
||||
|
||||
interceptor.postHandle(new ServletWebRequest(request), null);
|
||||
assertTrue(TransactionSynchronizationManager.hasResource(pmf));
|
||||
|
||||
interceptor.afterCompletion(new ServletWebRequest(request), null);
|
||||
assertFalse(TransactionSynchronizationManager.hasResource(pmf));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testOpenPersistenceManagerInViewFilter() throws Exception {
|
||||
final PersistenceManagerFactory pmf = mock(PersistenceManagerFactory.class);
|
||||
PersistenceManager pm = mock(PersistenceManager.class);
|
||||
|
||||
given(pmf.getPersistenceManager()).willReturn(pm);
|
||||
final PersistenceManagerFactory pmf2 = mock(PersistenceManagerFactory.class);
|
||||
PersistenceManager pm2 = mock(PersistenceManager.class);
|
||||
|
||||
given(pmf2.getPersistenceManager()).willReturn(pm2);
|
||||
|
||||
MockServletContext sc = new MockServletContext();
|
||||
StaticWebApplicationContext wac = new StaticWebApplicationContext();
|
||||
wac.setServletContext(sc);
|
||||
wac.getDefaultListableBeanFactory().registerSingleton("persistenceManagerFactory", pmf);
|
||||
wac.getDefaultListableBeanFactory().registerSingleton("myPersistenceManagerFactory", pmf2);
|
||||
wac.refresh();
|
||||
sc.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, wac);
|
||||
MockHttpServletRequest request = new MockHttpServletRequest(sc);
|
||||
MockHttpServletResponse response = new MockHttpServletResponse();
|
||||
|
||||
MockFilterConfig filterConfig = new MockFilterConfig(wac.getServletContext(), "filter");
|
||||
MockFilterConfig filterConfig2 = new MockFilterConfig(wac.getServletContext(), "filter2");
|
||||
filterConfig2.addInitParameter("persistenceManagerFactoryBeanName", "myPersistenceManagerFactory");
|
||||
|
||||
final OpenPersistenceManagerInViewFilter filter = new OpenPersistenceManagerInViewFilter();
|
||||
filter.init(filterConfig);
|
||||
final OpenPersistenceManagerInViewFilter filter2 = new OpenPersistenceManagerInViewFilter();
|
||||
filter2.init(filterConfig2);
|
||||
|
||||
final FilterChain filterChain = new FilterChain() {
|
||||
@Override
|
||||
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse) {
|
||||
assertTrue(TransactionSynchronizationManager.hasResource(pmf));
|
||||
servletRequest.setAttribute("invoked", Boolean.TRUE);
|
||||
}
|
||||
};
|
||||
|
||||
final FilterChain filterChain2 = new FilterChain() {
|
||||
@Override
|
||||
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse)
|
||||
throws IOException, ServletException {
|
||||
assertTrue(TransactionSynchronizationManager.hasResource(pmf2));
|
||||
filter.doFilter(servletRequest, servletResponse, filterChain);
|
||||
}
|
||||
};
|
||||
|
||||
FilterChain filterChain3 = new PassThroughFilterChain(filter2, filterChain2);
|
||||
|
||||
assertFalse(TransactionSynchronizationManager.hasResource(pmf));
|
||||
assertFalse(TransactionSynchronizationManager.hasResource(pmf2));
|
||||
filter2.doFilter(request, response, filterChain3);
|
||||
assertFalse(TransactionSynchronizationManager.hasResource(pmf));
|
||||
assertFalse(TransactionSynchronizationManager.hasResource(pmf2));
|
||||
assertNotNull(request.getAttribute("invoked"));
|
||||
|
||||
verify(pm).close();
|
||||
verify(pm2).close();
|
||||
|
||||
wac.close();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1 +0,0 @@
|
||||
myKey=myValue
|
||||
Reference in New Issue
Block a user