Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch '3.2.x'

Browse Source 
* 3.2.x: (28 commits)
  Hide 'doc' changes from jdiff reports
  Document @Bean 'lite' mode vs @Configuration
  Final preparations for 3.2.2
  Remove Tiles 3 configuration method
  Polishing
  Extracted buildRequestAttributes template method from FrameworkServlet
  Added "beforeExistingAdvisors" flag to AbstractAdvisingBeanPostProcessor
  Minor refinements along the way of researching static CGLIB callbacks
  Compare Kind references before checking log levels
  Polish Javadoc in RequestAttributes
  Fix copy-n-paste errors in NativeWebRequest
  Fix issue with restoring included attributes
  Add additional test for daylight savings glitch
  Document context hierarchy support in the TCF
  Fix test for daylight savings glitch
  Make the methodParameter field of HandlerMethod final
  Disable AsyncTests in spring-test-mvc
  Reformat the testing chapter
  Document context hierarchy support in the TCF
  Document context hierarchy support in the TCF
  ...
This commit is contained in:
Phillip Webb
2013-03-13 14:01:46 -07:00
parent ce4be3b46b f62f697550
commit 4e1cab28df
267 changed files with 8384 additions and 6246 deletions
Download Patch File Download Diff File Expand all files Collapse all files

95
spring-tx/src/test/java/org/springframework/jca/cci/CciLocalTransactionTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2012 the original author or authors.
* 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.
@@ -16,9 +16,6 @@
package org.springframework.jca.cci;
import static org.easymock.EasyMock.*;
import static org.junit.Assert.assertTrue;
import javax.resource.ResourceException;
import javax.resource.cci.Connection;
import javax.resource.cci.ConnectionFactory;
@@ -29,6 +26,7 @@ import javax.resource.cci.Record;
import org.junit.Test;
import org.springframework.dao.DataRetrievalFailureException;
import org.springframework.jca.cci.connection.CciLocalTransactionManager;
import org.springframework.jca.cci.core.CciTemplate;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallback;
@@ -36,6 +34,9 @@ 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 Thierry Templier
* @author Chris Beams
@@ -49,34 +50,20 @@ public class CciLocalTransactionTests {
*/
@Test
public void testLocalTransactionCommit() throws ResourceException {
final ConnectionFactory connectionFactory = createMock(ConnectionFactory.class);
Connection connection = createMock(Connection.class);
Interaction interaction = createMock(Interaction.class);
LocalTransaction localTransaction = createMock(LocalTransaction.class);
final Record record = createMock(Record.class);
final InteractionSpec interactionSpec = createMock(InteractionSpec.class);
final ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
Connection connection = mock(Connection.class);
Interaction interaction = mock(Interaction.class);
LocalTransaction localTransaction = mock(LocalTransaction.class);
final Record record = mock(Record.class);
final InteractionSpec interactionSpec = mock(InteractionSpec.class);
expect(connectionFactory.getConnection()).andReturn(connection);
given(connectionFactory.getConnection()).willReturn(connection);
given(connection.getLocalTransaction()).willReturn(localTransaction);
given(connection.createInteraction()).willReturn(interaction);
given(interaction.execute(interactionSpec, record, record)).willReturn(true);
given(connection.getLocalTransaction()).willReturn(localTransaction);
expect(connection.getLocalTransaction()).andReturn(localTransaction);
localTransaction.begin();
expect(connection.createInteraction()).andReturn(interaction);
expect(interaction.execute(interactionSpec, record, record)).andReturn(true);
interaction.close();
expect(connection.getLocalTransaction()).andReturn(localTransaction);
localTransaction.commit();
connection.close();
replay(connectionFactory, connection, localTransaction, interaction, record);
org.springframework.jca.cci.connection.CciLocalTransactionManager tm = new org.springframework.jca.cci.connection.CciLocalTransactionManager();
CciLocalTransactionManager tm = new CciLocalTransactionManager();
tm.setConnectionFactory(connectionFactory);
TransactionTemplate tt = new TransactionTemplate(tm);
@@ -89,7 +76,10 @@ public class CciLocalTransactionTests {
}
});
verify(connectionFactory, connection, localTransaction, interaction, record);
verify(localTransaction).begin();
verify(interaction).close();
verify(localTransaction).commit();
verify(connection).close();
}
/**
@@ -99,34 +89,20 @@ public class CciLocalTransactionTests {
*/
@Test
public void testLocalTransactionRollback() throws ResourceException {
final ConnectionFactory connectionFactory = createMock(ConnectionFactory.class);
Connection connection = createMock(Connection.class);
Interaction interaction = createMock(Interaction.class);
LocalTransaction localTransaction = createMock(LocalTransaction.class);
final Record record = createMock(Record.class);
final InteractionSpec interactionSpec = createMock(InteractionSpec.class);
final ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
Connection connection = mock(Connection.class);
Interaction interaction = mock(Interaction.class);
LocalTransaction localTransaction = mock(LocalTransaction.class);
final Record record = mock(Record.class);
final InteractionSpec interactionSpec = mock(InteractionSpec.class);
expect(connectionFactory.getConnection()).andReturn(connection);
given(connectionFactory.getConnection()).willReturn(connection);
given(connection.getLocalTransaction()).willReturn(localTransaction);
given(connection.createInteraction()).willReturn(interaction);
given(interaction.execute(interactionSpec, record, record)).willReturn(true);
given(connection.getLocalTransaction()).willReturn(localTransaction);
expect(connection.getLocalTransaction()).andReturn(localTransaction);
localTransaction.begin();
expect(connection.createInteraction()).andReturn(interaction);
expect(interaction.execute(interactionSpec, record, record)).andReturn(true);
interaction.close();
expect(connection.getLocalTransaction()).andReturn(localTransaction);
localTransaction.rollback();
connection.close();
replay(connectionFactory, connection, localTransaction, interaction, record);
org.springframework.jca.cci.connection.CciLocalTransactionManager tm = new org.springframework.jca.cci.connection.CciLocalTransactionManager();
CciLocalTransactionManager tm = new CciLocalTransactionManager();
tm.setConnectionFactory(connectionFactory);
TransactionTemplate tt = new TransactionTemplate(tm);
@@ -144,6 +120,9 @@ public class CciLocalTransactionTests {
catch (Exception ex) {
}
verify(connectionFactory, connection, localTransaction, interaction, record);
verify(localTransaction).begin();
verify(interaction).close();
verify(localTransaction).rollback();
verify(connection).close();
}
}

685
spring-tx/src/test/java/org/springframework/jca/cci/CciTemplateTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2012 the original author or authors.
* 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.
@@ -16,14 +16,6 @@
package org.springframework.jca.cci;
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.verify;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.sql.SQLException;
import javax.resource.NotSupportedException;
@@ -48,6 +40,9 @@ import org.springframework.jca.cci.core.InteractionCallback;
import org.springframework.jca.cci.core.RecordCreator;
import org.springframework.jca.cci.core.RecordExtractor;
import static org.junit.Assert.*;
import static org.mockito.BDDMockito.*;
/**
* @author Thierry Templier
* @author Juergen Hoeller
@@ -57,99 +52,73 @@ public class CciTemplateTests {
@Test
public void testCreateIndexedRecord() throws ResourceException {
ConnectionFactory connectionFactory = createMock(ConnectionFactory.class);
RecordFactory recordFactory = createMock(RecordFactory.class);
IndexedRecord indexedRecord = createMock(IndexedRecord.class);
expect(connectionFactory.getRecordFactory()).andReturn(recordFactory);
expect(recordFactory.createIndexedRecord("name")).andReturn(
indexedRecord);
replay(connectionFactory, recordFactory);
ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
RecordFactory recordFactory = mock(RecordFactory.class);
IndexedRecord indexedRecord = mock(IndexedRecord.class);
given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
given(recordFactory.createIndexedRecord("name")).willReturn(indexedRecord);
CciTemplate ct = new CciTemplate(connectionFactory);
ct.createIndexedRecord("name");
verify(connectionFactory, recordFactory);
verify(recordFactory).createIndexedRecord("name");
}
@Test
public void testCreateMappedRecord() throws ResourceException {
ConnectionFactory connectionFactory = createMock(ConnectionFactory.class);
RecordFactory recordFactory = createMock(RecordFactory.class);
MappedRecord mappedRecord = createMock(MappedRecord.class);
ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
RecordFactory recordFactory = mock(RecordFactory.class);
MappedRecord mappedRecord = mock(MappedRecord.class);
expect(connectionFactory.getRecordFactory()).andReturn(recordFactory);
expect(recordFactory.createMappedRecord("name"))
.andReturn(mappedRecord);
replay(connectionFactory, recordFactory);
given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
given(recordFactory.createMappedRecord("name")).willReturn(mappedRecord);
CciTemplate ct = new CciTemplate(connectionFactory);
ct.createMappedRecord("name");
verify(connectionFactory, recordFactory);
verify(recordFactory).createMappedRecord("name");
}
@Test
public void testTemplateExecuteInputOutput() throws ResourceException {
ConnectionFactory connectionFactory = createMock(ConnectionFactory.class);
Connection connection = createMock(Connection.class);
Interaction interaction = createMock(Interaction.class);
ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
Connection connection = mock(Connection.class);
Interaction interaction = mock(Interaction.class);
Record inputRecord = createMock(Record.class);
Record outputRecord = createMock(Record.class);
Record inputRecord = mock(Record.class);
Record outputRecord = mock(Record.class);
InteractionSpec interactionSpec = createMock(InteractionSpec.class);
InteractionSpec interactionSpec = mock(InteractionSpec.class);
expect(connectionFactory.getConnection()).andReturn(connection);
given(connectionFactory.getConnection()).willReturn(connection);
given(connection.createInteraction()).willReturn(interaction);
given(interaction.execute(interactionSpec, inputRecord, outputRecord)).willReturn(true);
expect(connection.createInteraction()).andReturn(interaction);
expect(interaction.execute(interactionSpec, inputRecord, outputRecord))
.andReturn(true);
interaction.close();
connection.close();
replay(connectionFactory, connection, interaction);
CciTemplate ct = new CciTemplate(connectionFactory);
ct.execute(interactionSpec, inputRecord, outputRecord);
verify(connectionFactory, connection, interaction);
verify(interaction).execute(interactionSpec, inputRecord, outputRecord);
verify(interaction).close();
verify(connection).close();
}
@Test
public void testTemplateExecuteWithCreatorAndRecordFactoryNotSupported()
throws ResourceException {
ConnectionFactory connectionFactory = createMock(ConnectionFactory.class);
Connection connection = createMock(Connection.class);
Interaction interaction = createMock(Interaction.class);
ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
Connection connection = mock(Connection.class);
Interaction interaction = mock(Interaction.class);
Record inputRecord = createMock(Record.class);
final Record outputRecord = createMock(Record.class);
Record inputRecord = mock(Record.class);
final Record outputRecord = mock(Record.class);
InteractionSpec interactionSpec = createMock(InteractionSpec.class);
InteractionSpec interactionSpec = mock(InteractionSpec.class);
expect(connectionFactory.getConnection()).andReturn(connection);
expect(connectionFactory.getRecordFactory()).andThrow(
new NotSupportedException("not supported"));
expect(connection.createInteraction()).andReturn(interaction);
expect(interaction.execute(interactionSpec, inputRecord, outputRecord))
.andReturn(true);
interaction.close();
connection.close();
replay(connectionFactory, connection, interaction);
given(connectionFactory.getConnection()).willReturn(connection);
given(connectionFactory.getRecordFactory()).willThrow(new NotSupportedException("not supported"));
given(connection.createInteraction()).willReturn(interaction);
given(interaction.execute(interactionSpec, inputRecord, outputRecord)).willReturn(true);
CciTemplate ct = new CciTemplate(connectionFactory);
ct.setOutputRecordCreator(new RecordCreator() {
@@ -161,352 +130,265 @@ public class CciTemplateTests {
});
ct.execute(interactionSpec, inputRecord);
verify(connectionFactory, connection, interaction);
verify(interaction).execute(interactionSpec, inputRecord, outputRecord);
verify(interaction).close();
verify(connection).close();
}
@Test
public void testTemplateExecuteInputTrueWithCreator2()
throws ResourceException {
ConnectionFactory connectionFactory = createMock(ConnectionFactory.class);
RecordFactory recordFactory = createMock(RecordFactory.class);
Connection connection = createMock(Connection.class);
Interaction interaction = createMock(Interaction.class);
RecordCreator creator = createMock(RecordCreator.class);
ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
RecordFactory recordFactory = mock(RecordFactory.class);
Connection connection = mock(Connection.class);
Interaction interaction = mock(Interaction.class);
RecordCreator creator = mock(RecordCreator.class);
Record inputRecord = createMock(Record.class);
final Record outputRecord = createMock(Record.class);
Record inputRecord = mock(Record.class);
final Record outputRecord = mock(Record.class);
InteractionSpec interactionSpec = createMock(InteractionSpec.class);
InteractionSpec interactionSpec = mock(InteractionSpec.class);
expect(connectionFactory.getConnection()).andReturn(connection);
expect(connectionFactory.getRecordFactory()).andReturn(recordFactory);
expect(connection.createInteraction()).andReturn(interaction);
expect(creator.createRecord(recordFactory)).andReturn(outputRecord);
expect(interaction.execute(interactionSpec, inputRecord, outputRecord))
.andReturn(true);
interaction.close();
connection.close();
replay(connectionFactory, connection, interaction, creator);
given(connectionFactory.getConnection()).willReturn(connection);
given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
given(connection.createInteraction()).willReturn(interaction);
given(creator.createRecord(recordFactory)).willReturn(outputRecord);
given(interaction.execute(interactionSpec, inputRecord, outputRecord)).willReturn(true);
CciTemplate ct = new CciTemplate(connectionFactory);
ct.setOutputRecordCreator(creator);
ct.execute(interactionSpec, inputRecord);
verify(connectionFactory, connection, interaction, creator);
verify(interaction).execute(interactionSpec, inputRecord, outputRecord);
verify(interaction).close();
verify(connection).close();
}
@Test
public void testTemplateExecuteInputFalse() throws ResourceException {
ConnectionFactory connectionFactory = createMock(ConnectionFactory.class);
Connection connection = createMock(Connection.class);
Interaction interaction = createMock(Interaction.class);
ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
Connection connection = mock(Connection.class);
Interaction interaction = mock(Interaction.class);
Record inputRecord = createMock(Record.class);
Record outputRecord = createMock(Record.class);
Record inputRecord = mock(Record.class);
Record outputRecord = mock(Record.class);
InteractionSpec interactionSpec = createMock(InteractionSpec.class);
InteractionSpec interactionSpec = mock(InteractionSpec.class);
expect(connectionFactory.getConnection()).andReturn(connection);
expect(connection.createInteraction()).andReturn(interaction);
expect(interaction.execute(interactionSpec, inputRecord)).andReturn(
outputRecord);
interaction.close();
connection.close();
replay(connectionFactory, connection, interaction);
given(connectionFactory.getConnection()).willReturn(connection);
given(connection.createInteraction()).willReturn(interaction);
given(interaction.execute(interactionSpec, inputRecord)).willReturn(outputRecord);
CciTemplate ct = new CciTemplate(connectionFactory);
ct.execute(interactionSpec, inputRecord);
verify(connectionFactory, connection, interaction);
verify(interaction).execute(interactionSpec, inputRecord);
verify(interaction).close();
verify(connection).close();
}
@SuppressWarnings("unchecked")
@Test
public void testTemplateExecuteInputExtractorTrueWithCreator()
throws ResourceException, SQLException {
ConnectionFactory connectionFactory = createMock(ConnectionFactory.class);
RecordFactory recordFactory = createMock(RecordFactory.class);
Connection connection = createMock(Connection.class);
Interaction interaction = createMock(Interaction.class);
RecordExtractor<Object> extractor = createMock(RecordExtractor.class);
RecordCreator creator = createMock(RecordCreator.class);
ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
RecordFactory recordFactory = mock(RecordFactory.class);
Connection connection = mock(Connection.class);
Interaction interaction = mock(Interaction.class);
RecordExtractor<Object> extractor = mock(RecordExtractor.class);
RecordCreator creator = mock(RecordCreator.class);
Record inputRecord = createMock(Record.class);
Record outputRecord = createMock(Record.class);
Record inputRecord = mock(Record.class);
Record outputRecord = mock(Record.class);
InteractionSpec interactionSpec = createMock(InteractionSpec.class);
InteractionSpec interactionSpec = mock(InteractionSpec.class);
expect(connectionFactory.getConnection()).andReturn(connection);
expect(connection.createInteraction()).andReturn(interaction);
expect(connectionFactory.getRecordFactory()).andReturn(recordFactory);
expect(creator.createRecord(recordFactory)).andReturn(outputRecord);
expect(interaction.execute(interactionSpec, inputRecord, outputRecord))
.andReturn(true);
expect(extractor.extractData(outputRecord)).andStubReturn(new Object());
interaction.close();
connection.close();
replay(connectionFactory, connection, interaction, extractor, creator);
given(connectionFactory.getConnection()).willReturn(connection);
given(connection.createInteraction()).willReturn(interaction);
given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
given(creator.createRecord(recordFactory)).willReturn(outputRecord);
given(interaction.execute(interactionSpec, inputRecord, outputRecord)).willReturn(true);
given(extractor.extractData(outputRecord)).willReturn(new Object());
CciTemplate ct = new CciTemplate(connectionFactory);
ct.setOutputRecordCreator(creator);
ct.execute(interactionSpec, inputRecord, extractor);
verify(connectionFactory, connection, interaction, extractor, creator);
verify(extractor).extractData(outputRecord);
verify(interaction).close();
verify(connection).close();
}
@SuppressWarnings("unchecked")
@Test
public void testTemplateExecuteInputExtractorFalse()
throws ResourceException, SQLException {
ConnectionFactory connectionFactory = createMock(ConnectionFactory.class);
Connection connection = createMock(Connection.class);
Interaction interaction = createMock(Interaction.class);
RecordExtractor<Object> extractor = createMock(RecordExtractor.class);
ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
Connection connection = mock(Connection.class);
Interaction interaction = mock(Interaction.class);
RecordExtractor<Object> extractor = mock(RecordExtractor.class);
Record inputRecord = createMock(Record.class);
Record outputRecord = createMock(Record.class);
Record inputRecord = mock(Record.class);
Record outputRecord = mock(Record.class);
InteractionSpec interactionSpec = createMock(InteractionSpec.class);
InteractionSpec interactionSpec = mock(InteractionSpec.class);
expect(connectionFactory.getConnection()).andReturn(connection);
expect(connection.createInteraction()).andReturn(interaction);
expect(interaction.execute(interactionSpec, inputRecord)).andReturn(
outputRecord);
expect(extractor.extractData(outputRecord)).andStubReturn(new Object());
interaction.close();
connection.close();
replay(connectionFactory, connection, interaction, extractor);
given(connectionFactory.getConnection()).willReturn(connection);
given(connection.createInteraction()).willReturn(interaction);
given(interaction.execute(interactionSpec, inputRecord)).willReturn(outputRecord);
given(extractor.extractData(outputRecord)).willReturn(new Object());
CciTemplate ct = new CciTemplate(connectionFactory);
ct.execute(interactionSpec, inputRecord, extractor);
verify(connectionFactory, connection, interaction, extractor);
verify(extractor).extractData(outputRecord);
verify(interaction).close();
verify(connection).close();
}
@Test
public void testTemplateExecuteInputGeneratorTrueWithCreator()
throws ResourceException {
ConnectionFactory connectionFactory = createMock(ConnectionFactory.class);
RecordFactory recordFactory = createMock(RecordFactory.class);
Connection connection = createMock(Connection.class);
Interaction interaction = createMock(Interaction.class);
RecordCreator generator = createMock(RecordCreator.class);
RecordCreator creator = createMock(RecordCreator.class);
ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
RecordFactory recordFactory = mock(RecordFactory.class);
Connection connection = mock(Connection.class);
Interaction interaction = mock(Interaction.class);
RecordCreator generator = mock(RecordCreator.class);
RecordCreator creator = mock(RecordCreator.class);
Record inputRecord = createMock(Record.class);
Record outputRecord = createMock(Record.class);
Record inputRecord = mock(Record.class);
Record outputRecord = mock(Record.class);
InteractionSpec interactionSpec = createMock(InteractionSpec.class);
InteractionSpec interactionSpec = mock(InteractionSpec.class);
expect(connectionFactory.getRecordFactory()).andReturn(recordFactory);
given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
given(generator.createRecord(recordFactory)).willReturn(inputRecord);
given(connectionFactory.getConnection()).willReturn(connection);
given(connection.createInteraction()).willReturn(interaction);
given(creator.createRecord(recordFactory)).willReturn(outputRecord);
given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
given(interaction.execute(interactionSpec, inputRecord, outputRecord)).willReturn(true);
expect(generator.createRecord(recordFactory)).andReturn(inputRecord);
expect(connectionFactory.getConnection()).andReturn(connection);
expect(connection.createInteraction()).andReturn(interaction);
expect(creator.createRecord(recordFactory)).andReturn(outputRecord);
expect(connectionFactory.getRecordFactory()).andReturn(recordFactory);
expect(interaction.execute(interactionSpec, inputRecord, outputRecord))
.andReturn(true);
interaction.close();
connection.close();
replay(connectionFactory, connection, interaction, generator, creator);
CciTemplate ct = new CciTemplate(connectionFactory);
ct.setOutputRecordCreator(creator);
ct.execute(interactionSpec, generator);
verify(connectionFactory, connection, interaction, generator, creator);
verify(interaction).execute(interactionSpec, inputRecord, outputRecord);
verify(interaction).close();
verify(connection).close();
}
@Test
public void testTemplateExecuteInputGeneratorFalse()
throws ResourceException {
ConnectionFactory connectionFactory = createMock(ConnectionFactory.class);
RecordFactory recordFactory = createMock(RecordFactory.class);
Connection connection = createMock(Connection.class);
Interaction interaction = createMock(Interaction.class);
RecordCreator generator = createMock(RecordCreator.class);
ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
RecordFactory recordFactory = mock(RecordFactory.class);
Connection connection = mock(Connection.class);
Interaction interaction = mock(Interaction.class);
RecordCreator generator = mock(RecordCreator.class);
Record inputRecord = createMock(Record.class);
Record outputRecord = createMock(Record.class);
Record inputRecord = mock(Record.class);
Record outputRecord = mock(Record.class);
InteractionSpec interactionSpec = createMock(InteractionSpec.class);
InteractionSpec interactionSpec = mock(InteractionSpec.class);
expect(connectionFactory.getRecordFactory()).andReturn(recordFactory);
expect(connectionFactory.getConnection()).andReturn(connection);
expect(connection.createInteraction()).andReturn(interaction);
expect(generator.createRecord(recordFactory)).andReturn(inputRecord);
expect(interaction.execute(interactionSpec, inputRecord)).andReturn(
outputRecord);
interaction.close();
connection.close();
replay(connectionFactory, connection, interaction, generator);
given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
given(connectionFactory.getConnection()).willReturn(connection);
given(connection.createInteraction()).willReturn(interaction);
given(generator.createRecord(recordFactory)).willReturn(inputRecord);
given(interaction.execute(interactionSpec, inputRecord)).willReturn(outputRecord);
CciTemplate ct = new CciTemplate(connectionFactory);
ct.execute(interactionSpec, generator);
verify(connectionFactory, connection, interaction, generator);
verify(interaction).execute(interactionSpec, inputRecord);
verify(interaction).close();
verify(connection).close();
}
@SuppressWarnings("unchecked")
@Test
public void testTemplateExecuteInputGeneratorExtractorTrueWithCreator()
throws ResourceException, SQLException {
ConnectionFactory connectionFactory = createMock(ConnectionFactory.class);
RecordFactory recordFactory = createMock(RecordFactory.class);
Connection connection = createMock(Connection.class);
Interaction interaction = createMock(Interaction.class);
RecordCreator generator = createMock(RecordCreator.class);
RecordExtractor<Object> extractor = createMock(RecordExtractor.class);
RecordCreator creator = createMock(RecordCreator.class);
ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
RecordFactory recordFactory = mock(RecordFactory.class);
Connection connection = mock(Connection.class);
Interaction interaction = mock(Interaction.class);
RecordCreator generator = mock(RecordCreator.class);
RecordExtractor<Object> extractor = mock(RecordExtractor.class);
RecordCreator creator = mock(RecordCreator.class);
Record inputRecord = createMock(Record.class);
Record outputRecord = createMock(Record.class);
Record inputRecord = mock(Record.class);
Record outputRecord = mock(Record.class);
Object obj = new Object();
InteractionSpec interactionSpec = createMock(InteractionSpec.class);
InteractionSpec interactionSpec = mock(InteractionSpec.class);
expect(connectionFactory.getRecordFactory()).andReturn(recordFactory);
expect(connectionFactory.getConnection()).andReturn(connection);
expect(connection.createInteraction()).andReturn(interaction);
expect(creator.createRecord(recordFactory)).andReturn(outputRecord);
expect(connectionFactory.getRecordFactory()).andReturn(recordFactory);
expect(generator.createRecord(recordFactory)).andReturn(inputRecord);
expect(interaction.execute(interactionSpec, inputRecord, outputRecord))
.andReturn(true);
expect(extractor.extractData(outputRecord)).andStubReturn(obj);
interaction.close();
connection.close();
replay(connectionFactory, connection, interaction, generator, creator,
extractor);
given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
given(connectionFactory.getConnection()).willReturn(connection);
given(connection.createInteraction()).willReturn(interaction);
given(creator.createRecord(recordFactory)).willReturn(outputRecord);
given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
given(generator.createRecord(recordFactory)).willReturn(inputRecord);
given(interaction.execute(interactionSpec, inputRecord, outputRecord)).willReturn(true);
given(extractor.extractData(outputRecord)).willReturn(obj);
CciTemplate ct = new CciTemplate(connectionFactory);
ct.setOutputRecordCreator(creator);
assertEquals(obj, ct.execute(interactionSpec, generator, extractor));
verify(connectionFactory, connection, interaction, generator, creator,
extractor);
verify(interaction).close();
verify(connection).close();
}
@SuppressWarnings("unchecked")
@Test
public void testTemplateExecuteInputGeneratorExtractorFalse()
throws ResourceException, SQLException {
ConnectionFactory connectionFactory = createMock(ConnectionFactory.class);
RecordFactory recordFactory = createMock(RecordFactory.class);
Connection connection = createMock(Connection.class);
Interaction interaction = createMock(Interaction.class);
RecordCreator generator = createMock(RecordCreator.class);
RecordExtractor<Object> extractor = createMock(RecordExtractor.class);
ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
RecordFactory recordFactory = mock(RecordFactory.class);
Connection connection = mock(Connection.class);
Interaction interaction = mock(Interaction.class);
RecordCreator generator = mock(RecordCreator.class);
RecordExtractor<Object> extractor = mock(RecordExtractor.class);
Record inputRecord = createMock(Record.class);
Record outputRecord = createMock(Record.class);
Record inputRecord = mock(Record.class);
Record outputRecord = mock(Record.class);
InteractionSpec interactionSpec = createMock(InteractionSpec.class);
InteractionSpec interactionSpec = mock(InteractionSpec.class);
expect(connectionFactory.getRecordFactory()).andReturn(recordFactory);
expect(connectionFactory.getConnection()).andReturn(connection);
expect(connection.createInteraction()).andReturn(interaction);
expect(generator.createRecord(recordFactory)).andReturn(inputRecord);
expect(interaction.execute(interactionSpec, inputRecord)).andReturn(
outputRecord);
expect(extractor.extractData(outputRecord)).andStubReturn(new Object());
interaction.close();
connection.close();
replay(connectionFactory, connection, interaction, generator, extractor);
given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
given(connectionFactory.getConnection()).willReturn(connection);
given(connection.createInteraction()).willReturn(interaction);
given(generator.createRecord(recordFactory)).willReturn(inputRecord);
given(interaction.execute(interactionSpec, inputRecord)).willReturn(outputRecord);
given(extractor.extractData(outputRecord)).willReturn(new Object());
CciTemplate ct = new CciTemplate(connectionFactory);
ct.execute(interactionSpec, generator, extractor);
verify(connectionFactory, connection, interaction, generator, extractor);
verify(extractor).extractData(outputRecord);
verify(interaction).close();
verify(connection).close();
}
@Test
public void testTemplateExecuteInputOutputConnectionSpec()
throws ResourceException {
ConnectionFactory connectionFactory = createMock(ConnectionFactory.class);
ConnectionSpec connectionSpec = createMock(ConnectionSpec.class);
Connection connection = createMock(Connection.class);
Interaction interaction = createMock(Interaction.class);
public void testTemplateExecuteInputOutputConnectionSpec() throws ResourceException {
ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
ConnectionSpec connectionSpec = mock(ConnectionSpec.class);
Connection connection = mock(Connection.class);
Interaction interaction = mock(Interaction.class);
Record inputRecord = createMock(Record.class);
Record outputRecord = createMock(Record.class);
Record inputRecord = mock(Record.class);
Record outputRecord = mock(Record.class);
InteractionSpec interactionSpec = createMock(InteractionSpec.class);
InteractionSpec interactionSpec = mock(InteractionSpec.class);
expect(connectionFactory.getConnection(connectionSpec)).andReturn(
connection);
expect(connection.createInteraction()).andReturn(interaction);
expect(interaction.execute(interactionSpec, inputRecord, outputRecord))
.andReturn(true);
interaction.close();
connection.close();
replay(connectionFactory, connection, interaction);
given(connectionFactory.getConnection(connectionSpec)).willReturn(connection);
given(connection.createInteraction()).willReturn(interaction);
given(interaction.execute(interactionSpec, inputRecord, outputRecord)).willReturn(true);
ConnectionSpecConnectionFactoryAdapter adapter = new ConnectionSpecConnectionFactoryAdapter();
adapter.setTargetConnectionFactory(connectionFactory);
@@ -514,197 +396,146 @@ public class CciTemplateTests {
CciTemplate ct = new CciTemplate(adapter);
ct.execute(interactionSpec, inputRecord, outputRecord);
verify(connectionFactory, connection, interaction);
verify(interaction).execute(interactionSpec, inputRecord, outputRecord);
verify(interaction).close();
verify(connection).close();
}
@SuppressWarnings("unchecked")
@Test
public void testTemplateExecuteInputOutputResultsSetFalse()
throws ResourceException, SQLException {
ConnectionFactory connectionFactory = createMock(ConnectionFactory.class);
RecordFactory recordFactory = createMock(RecordFactory.class);
Connection connection = createMock(Connection.class);
Interaction interaction = createMock(Interaction.class);
Record record = createMock(Record.class);
ResultSet resultset = createMock(ResultSet.class);
RecordCreator generator = createMock(RecordCreator.class);
RecordExtractor<Object> extractor = createMock(RecordExtractor.class);
ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
RecordFactory recordFactory = mock(RecordFactory.class);
Connection connection = mock(Connection.class);
Interaction interaction = mock(Interaction.class);
Record record = mock(Record.class);
ResultSet resultset = mock(ResultSet.class);
RecordCreator generator = mock(RecordCreator.class);
RecordExtractor<Object> extractor = mock(RecordExtractor.class);
InteractionSpec interactionSpec = createMock(InteractionSpec.class);
InteractionSpec interactionSpec = mock(InteractionSpec.class);
expect(connectionFactory.getRecordFactory()).andReturn(recordFactory);
expect(connectionFactory.getConnection()).andReturn(connection);
expect(connection.createInteraction()).andReturn(interaction);
expect(generator.createRecord(recordFactory)).andReturn(record);
expect(interaction.execute(interactionSpec, record)).andReturn(
resultset);
expect(extractor.extractData(resultset)).andStubReturn(new Object());
resultset.close();
interaction.close();
connection.close();
replay(connectionFactory, connection, interaction, generator,
extractor, resultset);
given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
given(connectionFactory.getConnection()).willReturn(connection);
given(connection.createInteraction()).willReturn(interaction);
given(generator.createRecord(recordFactory)).willReturn(record);
given(interaction.execute(interactionSpec, record)).willReturn(resultset);
given(extractor.extractData(resultset)).willReturn(new Object());
CciTemplate ct = new CciTemplate(connectionFactory);
ct.execute(interactionSpec, generator, extractor);
verify(connectionFactory, connection, interaction, generator,
extractor, resultset);
verify(extractor).extractData(resultset);
verify(resultset).close();
verify(interaction).close();
verify(connection).close();
}
@SuppressWarnings("unchecked")
@Test
public void testTemplateExecuteConnectionCallback()
throws ResourceException, SQLException {
ConnectionFactory connectionFactory = createMock(ConnectionFactory.class);
Connection connection = createMock(Connection.class);
ConnectionCallback<Object> connectionCallback = createMock(ConnectionCallback.class);
ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
Connection connection = mock(Connection.class);
ConnectionCallback<Object> connectionCallback = mock(ConnectionCallback.class);
expect(connectionFactory.getConnection()).andReturn(connection);
expect(connectionCallback.doInConnection(connection, connectionFactory))
.andStubReturn(new Object());
connection.close();
replay(connectionFactory, connection, connectionCallback);
given(connectionFactory.getConnection()).willReturn(connection);
given(connectionCallback.doInConnection(connection, connectionFactory)).willReturn(new Object());
CciTemplate ct = new CciTemplate(connectionFactory);
ct.execute(connectionCallback);
verify(connectionFactory, connection, connectionCallback);
verify(connectionCallback).doInConnection(connection, connectionFactory);
verify(connection).close();
}
@SuppressWarnings("unchecked")
@Test
public void testTemplateExecuteInteractionCallback()
throws ResourceException, SQLException {
ConnectionFactory connectionFactory = createMock(ConnectionFactory.class);
Connection connection = createMock(Connection.class);
Interaction interaction = createMock(Interaction.class);
InteractionCallback<Object> interactionCallback = createMock(InteractionCallback.class);
ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
Connection connection = mock(Connection.class);
Interaction interaction = mock(Interaction.class);
InteractionCallback<Object> interactionCallback = mock(InteractionCallback.class);
expect(connectionFactory.getConnection()).andReturn(connection);
expect(connection.createInteraction()).andReturn(interaction);
expect(
interactionCallback.doInInteraction(interaction,
connectionFactory)).andStubReturn(new Object());
interaction.close();
connection.close();
replay(connectionFactory, connection, interaction, interactionCallback);
given(connectionFactory.getConnection()).willReturn(connection);
given(connection.createInteraction()).willReturn(interaction);
given(interactionCallback.doInInteraction(interaction,connectionFactory)).willReturn(new Object());
CciTemplate ct = new CciTemplate(connectionFactory);
ct.execute(interactionCallback);
verify(connectionFactory, connection, interaction, interactionCallback);
verify(interactionCallback).doInInteraction(interaction,connectionFactory);
verify(interaction).close();
verify(connection).close();
}
@Test
public void testTemplateExecuteInputTrueTrueWithCreator()
throws ResourceException {
ConnectionFactory connectionFactory = createMock(ConnectionFactory.class);
Connection connection = createMock(Connection.class);
Interaction interaction = createMock(Interaction.class);
RecordCreator creator = createMock(RecordCreator.class);
ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
Connection connection = mock(Connection.class);
Interaction interaction = mock(Interaction.class);
RecordCreator creator = mock(RecordCreator.class);
Record inputOutputRecord = createMock(Record.class);
Record inputOutputRecord = mock(Record.class);
InteractionSpec interactionSpec = createMock(InteractionSpec.class);
InteractionSpec interactionSpec = mock(InteractionSpec.class);
expect(connectionFactory.getConnection()).andReturn(connection);
expect(connection.createInteraction()).andReturn(interaction);
expect(
interaction.execute(interactionSpec, inputOutputRecord,
inputOutputRecord)).andReturn(true);
interaction.close();
connection.close();
replay(connectionFactory, connection, interaction, creator);
given(connectionFactory.getConnection()).willReturn(connection);
given(connection.createInteraction()).willReturn(interaction);
given(interaction.execute(interactionSpec, inputOutputRecord, inputOutputRecord)).willReturn(true);
CciTemplate ct = new CciTemplate(connectionFactory);
ct.setOutputRecordCreator(creator);
ct.execute(interactionSpec, inputOutputRecord, inputOutputRecord);
verify(connectionFactory, connection, interaction, creator);
verify(interaction).execute(interactionSpec, inputOutputRecord, inputOutputRecord);
verify(interaction).close();
verify(connection).close();
}
@Test
public void testTemplateExecuteInputTrueTrue() throws ResourceException {
ConnectionFactory connectionFactory = createMock(ConnectionFactory.class);
Connection connection = createMock(Connection.class);
Interaction interaction = createMock(Interaction.class);
ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
Connection connection = mock(Connection.class);
Interaction interaction = mock(Interaction.class);
Record inputOutputRecord = mock(Record.class);
InteractionSpec interactionSpec = mock(InteractionSpec.class);
Record inputOutputRecord = createMock(Record.class);
InteractionSpec interactionSpec = createMock(InteractionSpec.class);
expect(connectionFactory.getConnection()).andReturn(connection);
expect(connection.createInteraction()).andReturn(interaction);
expect(
interaction.execute(interactionSpec, inputOutputRecord,
inputOutputRecord)).andReturn(true);
interaction.close();
connection.close();
replay(connectionFactory, connection, interaction);
given(connectionFactory.getConnection()).willReturn(connection);
given(connection.createInteraction()).willReturn(interaction);
given(interaction.execute(interactionSpec, inputOutputRecord, inputOutputRecord)).willReturn(true);
CciTemplate ct = new CciTemplate(connectionFactory);
ct.execute(interactionSpec, inputOutputRecord, inputOutputRecord);
verify(connectionFactory, connection, interaction);
verify(interaction).execute(interactionSpec, inputOutputRecord, inputOutputRecord);
verify(interaction).close();
verify(connection).close();
}
@Test
public void testTemplateExecuteInputFalseTrue() throws ResourceException {
ConnectionFactory connectionFactory = createMock(ConnectionFactory.class);
Connection connection = createMock(Connection.class);
Interaction interaction = createMock(Interaction.class);
ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
Connection connection = mock(Connection.class);
Interaction interaction = mock(Interaction.class);
Record inputOutputRecord = mock(Record.class);
InteractionSpec interactionSpec = mock(InteractionSpec.class);
Record inputOutputRecord = createMock(Record.class);
InteractionSpec interactionSpec = createMock(InteractionSpec.class);
expect(connectionFactory.getConnection()).andReturn(connection);
expect(connection.createInteraction()).andReturn(interaction);
expect(interaction.execute(interactionSpec, inputOutputRecord))
.andReturn(null);
interaction.close();
connection.close();
replay(connectionFactory, connection, interaction);
given(connectionFactory.getConnection()).willReturn(connection);
given(connection.createInteraction()).willReturn(interaction);
given(interaction.execute(interactionSpec, inputOutputRecord)).willReturn(null);
CciTemplate ct = new CciTemplate(connectionFactory);
Record tmpOutputRecord = ct.execute(interactionSpec,
inputOutputRecord);
assertNull(tmpOutputRecord);
verify(connectionFactory, connection, interaction);
verify(interaction).execute(interactionSpec, inputOutputRecord);
verify(interaction).close();
verify(connection).close();
}
}

190
spring-tx/src/test/java/org/springframework/jca/cci/EisOperationTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2012 the original author or authors.
* 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.
@@ -16,9 +16,6 @@
package org.springframework.jca.cci;
import static org.easymock.EasyMock.*;
import static org.junit.Assert.assertSame;
import javax.resource.ResourceException;
import javax.resource.cci.Connection;
import javax.resource.cci.ConnectionFactory;
@@ -32,6 +29,9 @@ import org.springframework.jca.cci.core.RecordCreator;
import org.springframework.jca.cci.object.MappingRecordOperation;
import org.springframework.jca.cci.object.SimpleRecordOperation;
import static org.junit.Assert.*;
import static org.mockito.BDDMockito.*;
/**
* @author Thierry Templier
* @author Chris Beams
@@ -40,106 +40,88 @@ public class EisOperationTests {
@Test
public void testSimpleRecordOperation() throws ResourceException {
ConnectionFactory connectionFactory = createMock(ConnectionFactory.class);
Connection connection = createMock(Connection.class);
Interaction interaction = createMock(Interaction.class);
ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
Connection connection = mock(Connection.class);
Interaction interaction = mock(Interaction.class);
Record inputRecord = createMock(Record.class);
Record outputRecord = createMock(Record.class);
Record inputRecord = mock(Record.class);
Record outputRecord = mock(Record.class);
InteractionSpec interactionSpec = createMock(InteractionSpec.class);
InteractionSpec interactionSpec = mock(InteractionSpec.class);
SimpleRecordOperation query = new SimpleRecordOperation(connectionFactory, interactionSpec);
expect(connectionFactory.getConnection()).andReturn(connection);
expect(connection.createInteraction()).andReturn(interaction);
expect(interaction.execute(interactionSpec, inputRecord)).andReturn(outputRecord);
interaction.close();
connection.close();
replay(connectionFactory, connection, interaction);
given(connectionFactory.getConnection()).willReturn(connection);
given(connection.createInteraction()).willReturn(interaction);
given(interaction.execute(interactionSpec, inputRecord)).willReturn(outputRecord);
query.execute(inputRecord);
verify(connectionFactory, connection, interaction);
verify(interaction).execute(interactionSpec, inputRecord);
verify(interaction).close();
verify(connection).close();
}
@Test
public void testSimpleRecordOperationWithExplicitOutputRecord() throws ResourceException {
ConnectionFactory connectionFactory = createMock(ConnectionFactory.class);
Connection connection = createMock(Connection.class);
Interaction interaction = createMock(Interaction.class);
ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
Connection connection = mock(Connection.class);
Interaction interaction = mock(Interaction.class);
Record inputRecord = createMock(Record.class);
Record outputRecord = createMock(Record.class);
Record inputRecord = mock(Record.class);
Record outputRecord = mock(Record.class);
InteractionSpec interactionSpec = createMock(InteractionSpec.class);
InteractionSpec interactionSpec = mock(InteractionSpec.class);
SimpleRecordOperation operation = new SimpleRecordOperation(connectionFactory, interactionSpec);
expect(connectionFactory.getConnection()).andReturn(connection);
expect(connection.createInteraction()).andReturn(interaction);
expect(interaction.execute(interactionSpec, inputRecord, outputRecord)).andReturn(true);
interaction.close();
connection.close();
replay(connectionFactory, connection, interaction);
given(connectionFactory.getConnection()).willReturn(connection);
given(connection.createInteraction()).willReturn(interaction);
given(interaction.execute(interactionSpec, inputRecord, outputRecord)).willReturn(true);
operation.execute(inputRecord, outputRecord);
verify(connectionFactory, connection, interaction);
verify(interaction).execute(interactionSpec, inputRecord, outputRecord);
verify(interaction).close();
verify(connection).close();
}
@Test
public void testSimpleRecordOperationWithInputOutputRecord() throws ResourceException {
ConnectionFactory connectionFactory = createMock(ConnectionFactory.class);
Connection connection = createMock(Connection.class);
Interaction interaction = createMock(Interaction.class);
ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
Connection connection = mock(Connection.class);
Interaction interaction = mock(Interaction.class);
Record inputOutputRecord = createMock(Record.class);
Record inputOutputRecord = mock(Record.class);
InteractionSpec interactionSpec = createMock(InteractionSpec.class);
InteractionSpec interactionSpec = mock(InteractionSpec.class);
SimpleRecordOperation query = new SimpleRecordOperation(connectionFactory, interactionSpec);
expect(connectionFactory.getConnection()).andReturn(connection);
expect(connection.createInteraction()).andReturn(interaction);
expect(interaction.execute(interactionSpec, inputOutputRecord, inputOutputRecord)).andReturn(true);
interaction.close();
connection.close();
replay(connectionFactory, connection, interaction);
given(connectionFactory.getConnection()).willReturn(connection);
given(connection.createInteraction()).willReturn(interaction);
given(interaction.execute(interactionSpec, inputOutputRecord, inputOutputRecord)).willReturn(true);
query.execute(inputOutputRecord, inputOutputRecord);
verify(connectionFactory, connection, interaction);
verify(interaction).execute(interactionSpec, inputOutputRecord, inputOutputRecord);
verify(interaction).close();
verify(connection).close();
}
@Test
public void testMappingRecordOperation() throws ResourceException {
ConnectionFactory connectionFactory = createMock(ConnectionFactory.class);
Connection connection = createMock(Connection.class);
Interaction interaction = createMock(Interaction.class);
RecordFactory recordFactory = createMock(RecordFactory.class);
ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
Connection connection = mock(Connection.class);
Interaction interaction = mock(Interaction.class);
RecordFactory recordFactory = mock(RecordFactory.class);
Record inputRecord = createMock(Record.class);
Record outputRecord = createMock(Record.class);
Record inputRecord = mock(Record.class);
Record outputRecord = mock(Record.class);
InteractionSpec interactionSpec = createMock(InteractionSpec.class);
InteractionSpec interactionSpec = mock(InteractionSpec.class);
QueryCallDetector callDetector = createMock(QueryCallDetector.class);
QueryCallDetector callDetector = mock(QueryCallDetector.class);
MappingRecordOperationImpl query = new MappingRecordOperationImpl(connectionFactory, interactionSpec);
query.setCallDetector(callDetector);
@@ -147,44 +129,33 @@ public class EisOperationTests {
Object inObj = new Object();
Object outObj = new Object();
expect(connectionFactory.getRecordFactory()).andReturn(recordFactory);
expect(callDetector.callCreateInputRecord(recordFactory, inObj)).andReturn(inputRecord);
expect(connectionFactory.getConnection()).andReturn(connection);
expect(connection.createInteraction()).andReturn(interaction);
expect(interaction.execute(interactionSpec, inputRecord)).andReturn(outputRecord);
expect(callDetector.callExtractOutputData(outputRecord)).andReturn(outObj);
interaction.close();
connection.close();
replay(connectionFactory, connection, interaction, callDetector);
given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
given(callDetector.callCreateInputRecord(recordFactory, inObj)).willReturn(inputRecord);
given(connectionFactory.getConnection()).willReturn(connection);
given(connection.createInteraction()).willReturn(interaction);
given(interaction.execute(interactionSpec, inputRecord)).willReturn(outputRecord);
given(callDetector.callExtractOutputData(outputRecord)).willReturn(outObj);
assertSame(outObj, query.execute(inObj));
verify(connectionFactory, connection, interaction, callDetector);
verify(interaction).close();
verify(connection).close();
}
@Test
public void testMappingRecordOperationWithOutputRecordCreator() throws ResourceException {
ConnectionFactory connectionFactory = createMock(ConnectionFactory.class);
Connection connection = createMock(Connection.class);
Interaction interaction = createMock(Interaction.class);
RecordFactory recordFactory = createMock(RecordFactory.class);
ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
Connection connection = mock(Connection.class);
Interaction interaction = mock(Interaction.class);
RecordFactory recordFactory = mock(RecordFactory.class);
Record inputRecord = createMock(Record.class);
Record outputRecord = createMock(Record.class);
Record inputRecord = mock(Record.class);
Record outputRecord = mock(Record.class);
RecordCreator outputCreator = createMock(RecordCreator.class);
RecordCreator outputCreator = mock(RecordCreator.class);
InteractionSpec interactionSpec = createMock(InteractionSpec.class);
InteractionSpec interactionSpec = mock(InteractionSpec.class);
QueryCallDetector callDetector = createMock(QueryCallDetector.class);
QueryCallDetector callDetector = mock(QueryCallDetector.class);
MappingRecordOperationImpl query = new MappingRecordOperationImpl(connectionFactory, interactionSpec);
query.setOutputRecordCreator(outputCreator);
@@ -193,31 +164,18 @@ public class EisOperationTests {
Object inObj = new Object();
Object outObj = new Object();
expect(connectionFactory.getRecordFactory()).andReturn(recordFactory);
expect(callDetector.callCreateInputRecord(recordFactory, inObj)).andReturn(inputRecord);
expect(connectionFactory.getConnection()).andReturn(connection);
expect(connection.createInteraction()).andReturn(interaction);
expect(connectionFactory.getRecordFactory()).andReturn(recordFactory);
expect(outputCreator.createRecord(recordFactory)).andReturn(outputRecord);
expect(interaction.execute(interactionSpec, inputRecord, outputRecord)).andReturn(true);
expect(callDetector.callExtractOutputData(outputRecord)).andReturn(outObj);
interaction.close();
connection.close();
replay(connectionFactory, connection, interaction, outputCreator, callDetector);
given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
given(callDetector.callCreateInputRecord(recordFactory, inObj)).willReturn(inputRecord);
given(connectionFactory.getConnection()).willReturn(connection);
given(connection.createInteraction()).willReturn(interaction);
given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
given(outputCreator.createRecord(recordFactory)).willReturn(outputRecord);
given(interaction.execute(interactionSpec, inputRecord, outputRecord)).willReturn(true);
given(callDetector.callExtractOutputData(outputRecord)).willReturn(outObj);
assertSame(outObj, query.execute(inObj));
verify(connectionFactory, connection, interaction, outputCreator, callDetector);
verify(interaction).close();
verify(connection).close();
}

32
spring-tx/src/test/java/org/springframework/jca/support/LocalConnectionFactoryBeanTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2006 the original author or authors.
* 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.
@@ -16,14 +16,14 @@
package org.springframework.jca.support;
import static org.easymock.EasyMock.*;
import static org.junit.Assert.*;
import javax.resource.spi.ConnectionManager;
import javax.resource.spi.ManagedConnectionFactory;
import org.junit.Test;
import static org.junit.Assert.*;
import static org.mockito.BDDMockito.*;
/**
* Unit tests for the {@link LocalConnectionFactoryBean} class.
*
@@ -51,38 +51,24 @@ public final class LocalConnectionFactoryBeanTests {
@Test
public void testCreatesVanillaConnectionFactoryIfNoConnectionManagerHasBeenConfigured() throws Exception {
final Object CONNECTION_FACTORY = new Object();
ManagedConnectionFactory managedConnectionFactory = createMock(ManagedConnectionFactory.class);
expect(managedConnectionFactory.createConnectionFactory()).andReturn(CONNECTION_FACTORY);
replay(managedConnectionFactory);
ManagedConnectionFactory managedConnectionFactory = mock(ManagedConnectionFactory.class);
given(managedConnectionFactory.createConnectionFactory()).willReturn(CONNECTION_FACTORY);
LocalConnectionFactoryBean factory = new LocalConnectionFactoryBean();
factory.setManagedConnectionFactory(managedConnectionFactory);
factory.afterPropertiesSet();
assertEquals(CONNECTION_FACTORY, factory.getObject());
verify(managedConnectionFactory);
}
@Test
public void testCreatesManagedConnectionFactoryIfAConnectionManagerHasBeenConfigured() throws Exception {
ManagedConnectionFactory managedConnectionFactory = createMock(ManagedConnectionFactory.class);
ConnectionManager connectionManager = createMock(ConnectionManager.class);
expect(managedConnectionFactory.createConnectionFactory(connectionManager)).andReturn(null);
replay(connectionManager, managedConnectionFactory);
ManagedConnectionFactory managedConnectionFactory = mock(ManagedConnectionFactory.class);
ConnectionManager connectionManager = mock(ConnectionManager.class);
LocalConnectionFactoryBean factory = new LocalConnectionFactoryBean();
factory.setManagedConnectionFactory(managedConnectionFactory);
factory.setConnectionManager(connectionManager);
factory.afterPropertiesSet();
verify(connectionManager, managedConnectionFactory);
verify(managedConnectionFactory).createConnectionFactory(connectionManager);
}
}

95
spring-tx/src/test/java/org/springframework/transaction/JndiJtaTransactionManagerTests.java
View File

@@ -21,7 +21,6 @@ import javax.transaction.TransactionManager;
import javax.transaction.UserTransaction;
import junit.framework.TestCase;
import org.easymock.MockControl;
import org.springframework.tests.mock.jndi.ExpectedLookupTemplate;
import org.springframework.transaction.jta.JtaTransactionManager;
@@ -30,6 +29,8 @@ import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import org.springframework.transaction.support.TransactionTemplate;
import static org.mockito.BDDMockito.*;
/**
* @author Juergen Hoeller
* @since 05.08.2005
@@ -55,33 +56,14 @@ public class JndiJtaTransactionManagerTests extends TestCase {
private void doTestJtaTransactionManagerWithDefaultJndiLookups(String tmName, boolean tmFound, boolean defaultUt)
throws Exception {
MockControl utControl = MockControl.createControl(UserTransaction.class);
UserTransaction ut = (UserTransaction) utControl.getMock();
UserTransaction ut = mock(UserTransaction.class);
TransactionManager tm = mock(TransactionManager.class);
if (defaultUt) {
ut.getStatus();
utControl.setReturnValue(Status.STATUS_NO_TRANSACTION, 1);
ut.getStatus();
utControl.setReturnValue(Status.STATUS_ACTIVE, 2);
ut.begin();
utControl.setVoidCallable(1);
ut.commit();
utControl.setVoidCallable(1);
given(ut.getStatus()).willReturn(Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE, Status.STATUS_ACTIVE);
}
utControl.replay();
MockControl tmControl = MockControl.createControl(TransactionManager.class);
TransactionManager tm = (TransactionManager) tmControl.getMock();
if (!defaultUt) {
tm.getStatus();
tmControl.setReturnValue(Status.STATUS_NO_TRANSACTION, 1);
tm.getStatus();
tmControl.setReturnValue(Status.STATUS_ACTIVE, 2);
tm.begin();
tmControl.setVoidCallable(1);
tm.commit();
tmControl.setVoidCallable(1);
else {
given(tm.getStatus()).willReturn(Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE, Status.STATUS_ACTIVE);
}
tmControl.replay();
JtaTransactionManager ptm = new JtaTransactionManager();
ExpectedLookupTemplate jndiTemplate = new ExpectedLookupTemplate();
@@ -122,25 +104,23 @@ public class JndiJtaTransactionManagerTests extends TestCase {
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
utControl.verify();
tmControl.verify();
if (defaultUt) {
verify(ut).begin();
verify(ut).commit();
}
else {
verify(tm).begin();
verify(tm).commit();
}
}
public void testJtaTransactionManagerWithCustomJndiLookups() throws Exception {
MockControl utControl = MockControl.createControl(UserTransaction.class);
UserTransaction ut = (UserTransaction) utControl.getMock();
ut.getStatus();
utControl.setReturnValue(Status.STATUS_NO_TRANSACTION, 1);
ut.getStatus();
utControl.setReturnValue(Status.STATUS_ACTIVE, 2);
ut.begin();
utControl.setVoidCallable(1);
ut.commit();
utControl.setVoidCallable(1);
utControl.replay();
UserTransaction ut = mock(UserTransaction.class);
given(ut.getStatus()).willReturn(Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE, Status.STATUS_ACTIVE);
MockControl tmControl = MockControl.createControl(TransactionManager.class);
TransactionManager tm = (TransactionManager) tmControl.getMock();
TransactionManager tm = mock(TransactionManager.class);
JtaTransactionManager ptm = new JtaTransactionManager();
ptm.setUserTransactionName("jndi-ut");
@@ -168,33 +148,16 @@ public class JndiJtaTransactionManagerTests extends TestCase {
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
utControl.verify();
verify(ut).begin();
verify(ut).commit();
}
public void testJtaTransactionManagerWithNotCacheUserTransaction() throws Exception {
MockControl utControl = MockControl.createControl(UserTransaction.class);
UserTransaction ut = (UserTransaction) utControl.getMock();
ut.getStatus();
utControl.setReturnValue(Status.STATUS_NO_TRANSACTION, 1);
ut.getStatus();
utControl.setReturnValue(Status.STATUS_ACTIVE, 2);
ut.begin();
utControl.setVoidCallable(1);
ut.commit();
utControl.setVoidCallable(1);
utControl.replay();
UserTransaction ut = mock(UserTransaction.class);
given(ut.getStatus()).willReturn(Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE, Status.STATUS_ACTIVE);
MockControl ut2Control = MockControl.createControl(UserTransaction.class);
UserTransaction ut2 = (UserTransaction) ut2Control.getMock();
ut2.getStatus();
ut2Control.setReturnValue(Status.STATUS_NO_TRANSACTION, 1);
ut2.getStatus();
ut2Control.setReturnValue(Status.STATUS_ACTIVE, 2);
ut2.begin();
ut2Control.setVoidCallable(1);
ut2.commit();
ut2Control.setVoidCallable(1);
ut2Control.replay();
UserTransaction ut2 = mock(UserTransaction.class);
given(ut2.getStatus()).willReturn(Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE, Status.STATUS_ACTIVE);
JtaTransactionManager ptm = new JtaTransactionManager();
ptm.setJndiTemplate(new ExpectedLookupTemplate("java:comp/UserTransaction", ut));
@@ -228,8 +191,10 @@ public class JndiJtaTransactionManagerTests extends TestCase {
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
utControl.verify();
ut2Control.verify();
verify(ut).begin();
verify(ut).commit();
verify(ut2).begin();
verify(ut2).commit();
}
/**

833
spring-tx/src/test/java/org/springframework/transaction/JtaTransactionManagerTests.java
View File

File diff suppressed because it is too large Load Diff

168
spring-tx/src/test/java/org/springframework/transaction/interceptor/AbstractTransactionAspectTests.java
View File

@@ -19,11 +19,10 @@ package org.springframework.transaction.interceptor;
import java.lang.reflect.Method;
import junit.framework.TestCase;
import org.easymock.MockControl;
import org.springframework.dao.OptimisticLockingFailureException;
import org.springframework.tests.sample.beans.ITestBean;
import org.springframework.tests.sample.beans.TestBean;
import org.springframework.dao.OptimisticLockingFailureException;
import org.springframework.transaction.CannotCreateTransactionException;
import org.springframework.transaction.MockCallbackPreferringTransactionManager;
import org.springframework.transaction.NoTransactionException;
@@ -34,6 +33,8 @@ import org.springframework.transaction.TransactionSystemException;
import org.springframework.transaction.UnexpectedRollbackException;
import org.springframework.transaction.interceptor.TransactionAspectSupport.TransactionInfo;
import static org.mockito.BDDMockito.*;
/**
* Mock object based tests for transaction aspects.
* True unit test in that it tests how the transaction aspect uses
@@ -69,11 +70,7 @@ public abstract class AbstractTransactionAspectTests extends TestCase {
public void testNoTransaction() throws Exception {
MockControl ptmControl = MockControl.createControl(PlatformTransactionManager.class);
PlatformTransactionManager ptm = (PlatformTransactionManager) ptmControl.getMock();
// expect no calls
ptmControl.replay();
PlatformTransactionManager ptm = mock(PlatformTransactionManager.class);
TestBean tb = new TestBean();
TransactionAttributeSource tas = new MapTransactionAttributeSource();
@@ -87,7 +84,8 @@ public abstract class AbstractTransactionAspectTests extends TestCase {
itb.getName();
checkTransactionStatus(false);
ptmControl.verify();
// expect no calls
verifyZeroInteractions(ptm);
}
/**
@@ -99,15 +97,10 @@ public abstract class AbstractTransactionAspectTests extends TestCase {
MapTransactionAttributeSource tas = new MapTransactionAttributeSource();
tas.register(getNameMethod, txatt);
TransactionStatus status = transactionStatusForNewTransaction();
MockControl ptmControl = MockControl.createControl(PlatformTransactionManager.class);
PlatformTransactionManager ptm = (PlatformTransactionManager) ptmControl.getMock();
TransactionStatus status = mock(TransactionStatus.class);
PlatformTransactionManager ptm = mock(PlatformTransactionManager.class);
// expect a transaction
ptm.getTransaction(txatt);
ptmControl.setReturnValue(status, 1);
ptm.commit(status);
ptmControl.setVoidCallable(1);
ptmControl.replay();
given(ptm.getTransaction(txatt)).willReturn(status);
TestBean tb = new TestBean();
ITestBean itb = (ITestBean) advised(tb, ptm, tas);
@@ -116,7 +109,7 @@ public abstract class AbstractTransactionAspectTests extends TestCase {
itb.getName();
checkTransactionStatus(false);
ptmControl.verify();
verify(ptm).commit(status);
}
/**
@@ -178,15 +171,10 @@ public abstract class AbstractTransactionAspectTests extends TestCase {
MapTransactionAttributeSource tas2 = new MapTransactionAttributeSource();
tas2.register(setNameMethod, txatt);
TransactionStatus status = transactionStatusForNewTransaction();
MockControl ptmControl = MockControl.createControl(PlatformTransactionManager.class);
PlatformTransactionManager ptm = (PlatformTransactionManager) ptmControl.getMock();
TransactionStatus status = mock(TransactionStatus.class);
PlatformTransactionManager ptm = mock(PlatformTransactionManager.class);
// expect a transaction
ptm.getTransaction(txatt);
ptmControl.setReturnValue(status, 2);
ptm.commit(status);
ptmControl.setVoidCallable(2);
ptmControl.replay();
given(ptm.getTransaction(txatt)).willReturn(status);
TestBean tb = new TestBean();
ITestBean itb = (ITestBean) advised(tb, ptm, new TransactionAttributeSource[] {tas1, tas2});
@@ -197,7 +185,7 @@ public abstract class AbstractTransactionAspectTests extends TestCase {
itb.setName("myName");
checkTransactionStatus(false);
ptmControl.verify();
verify(ptm, times(2)).commit(status);
}
/**
@@ -209,16 +197,10 @@ public abstract class AbstractTransactionAspectTests extends TestCase {
MapTransactionAttributeSource tas = new MapTransactionAttributeSource();
tas.register(getNameMethod, txatt);
MockControl statusControl = MockControl.createControl(TransactionStatus.class);
TransactionStatus status = (TransactionStatus) statusControl.getMock();
MockControl ptmControl = MockControl.createControl(PlatformTransactionManager.class);
PlatformTransactionManager ptm = (PlatformTransactionManager) ptmControl.getMock();
TransactionStatus status = mock(TransactionStatus.class);
PlatformTransactionManager ptm = mock(PlatformTransactionManager.class);
// expect a transaction
ptm.getTransaction(txatt);
ptmControl.setReturnValue(status, 1);
ptm.commit(status);
ptmControl.setVoidCallable(1);
ptmControl.replay();
given(ptm.getTransaction(txatt)).willReturn(status);
TestBean tb = new TestBean();
ITestBean itb = (ITestBean) advised(tb, ptm, tas);
@@ -228,7 +210,7 @@ public abstract class AbstractTransactionAspectTests extends TestCase {
itb.getName();
checkTransactionStatus(false);
ptmControl.verify();
verify(ptm).commit(status);
}
public void testEnclosingTransactionWithNonTransactionMethodOnAdvisedInside() throws Throwable {
@@ -237,15 +219,10 @@ public abstract class AbstractTransactionAspectTests extends TestCase {
MapTransactionAttributeSource tas = new MapTransactionAttributeSource();
tas.register(exceptionalMethod, txatt);
TransactionStatus status = transactionStatusForNewTransaction();
MockControl ptmControl = MockControl.createControl(PlatformTransactionManager.class);
PlatformTransactionManager ptm = (PlatformTransactionManager) ptmControl.getMock();
TransactionStatus status = mock(TransactionStatus.class);
PlatformTransactionManager ptm = mock(PlatformTransactionManager.class);
// Expect a transaction
ptm.getTransaction(txatt);
ptmControl.setReturnValue(status, 1);
ptm.commit(status);
ptmControl.setVoidCallable(1);
ptmControl.replay();
given(ptm.getTransaction(txatt)).willReturn(status);
final String spouseName = "innerName";
@@ -278,7 +255,7 @@ public abstract class AbstractTransactionAspectTests extends TestCase {
checkTransactionStatus(false);
ptmControl.verify();
verify(ptm).commit(status);
}
public void testEnclosingTransactionWithNestedTransactionOnAdvisedInside() throws Throwable {
@@ -291,24 +268,13 @@ public abstract class AbstractTransactionAspectTests extends TestCase {
tas.register(outerMethod, outerTxatt);
tas.register(innerMethod, innerTxatt);
TransactionStatus outerStatus = transactionStatusForNewTransaction();
TransactionStatus innerStatus = transactionStatusForNewTransaction();
TransactionStatus outerStatus = mock(TransactionStatus.class);
TransactionStatus innerStatus = mock(TransactionStatus.class);
MockControl ptmControl = MockControl.createControl(PlatformTransactionManager.class);
PlatformTransactionManager ptm = (PlatformTransactionManager) ptmControl.getMock();
PlatformTransactionManager ptm = mock(PlatformTransactionManager.class);
// Expect a transaction
ptm.getTransaction(outerTxatt);
ptmControl.setReturnValue(outerStatus, 1);
ptm.getTransaction(innerTxatt);
ptmControl.setReturnValue(innerStatus, 1);
ptm.commit(innerStatus);
ptmControl.setVoidCallable(1);
ptm.commit(outerStatus);
ptmControl.setVoidCallable(1);
ptmControl.replay();
given(ptm.getTransaction(outerTxatt)).willReturn(outerStatus);
given(ptm.getTransaction(innerTxatt)).willReturn(innerStatus);
final String spouseName = "innerName";
@@ -344,7 +310,8 @@ public abstract class AbstractTransactionAspectTests extends TestCase {
checkTransactionStatus(false);
ptmControl.verify();
verify(ptm).commit(innerStatus);
verify(ptm).commit(outerStatus);
}
public void testRollbackOnCheckedException() throws Throwable {
@@ -401,29 +368,21 @@ public abstract class AbstractTransactionAspectTests extends TestCase {
MapTransactionAttributeSource tas = new MapTransactionAttributeSource();
tas.register(m, txatt);
MockControl statusControl = MockControl.createControl(TransactionStatus.class);
TransactionStatus status = (TransactionStatus) statusControl.getMock();
MockControl ptmControl = MockControl.createControl(PlatformTransactionManager.class);
PlatformTransactionManager ptm = (PlatformTransactionManager) ptmControl.getMock();
TransactionStatus status = mock(TransactionStatus.class);
PlatformTransactionManager ptm = mock(PlatformTransactionManager.class);
// Gets additional call(s) from TransactionControl
ptm.getTransaction(txatt);
ptmControl.setReturnValue(status, 1);
given(ptm.getTransaction(txatt)).willReturn(status);
if (shouldRollback) {
ptm.rollback(status);
}
else {
ptm.commit(status);
}
TransactionSystemException tex = new TransactionSystemException("system exception");
if (rollbackException) {
ptmControl.setThrowable(tex, 1);
if (shouldRollback) {
willThrow(tex).given(ptm).rollback(status);
}
else {
willThrow(tex).given(ptm).commit(status);
}
}
else {
ptmControl.setVoidCallable(1);
}
ptmControl.replay();
TestBean tb = new TestBean();
ITestBean itb = (ITestBean) advised(tb, ptm, tas);
@@ -441,7 +400,14 @@ public abstract class AbstractTransactionAspectTests extends TestCase {
}
}
ptmControl.verify();
if (!rollbackException) {
if (shouldRollback) {
verify(ptm).rollback(status);
}
else {
verify(ptm).commit(status);
}
}
}
/**
@@ -454,15 +420,10 @@ public abstract class AbstractTransactionAspectTests extends TestCase {
MapTransactionAttributeSource tas = new MapTransactionAttributeSource();
tas.register(m, txatt);
TransactionStatus status = transactionStatusForNewTransaction();
MockControl ptmControl = MockControl.createControl(PlatformTransactionManager.class);
PlatformTransactionManager ptm = (PlatformTransactionManager) ptmControl.getMock();
TransactionStatus status = mock(TransactionStatus.class);
PlatformTransactionManager ptm = mock(PlatformTransactionManager.class);
ptm.getTransaction(txatt);
ptmControl.setReturnValue(status, 1);
ptm.commit(status);
ptmControl.setVoidCallable(1);
ptmControl.replay();
given(ptm.getTransaction(txatt)).willReturn(status);
final String name = "jenny";
TestBean tb = new TestBean() {
@@ -479,15 +440,7 @@ public abstract class AbstractTransactionAspectTests extends TestCase {
// verification!?
assertTrue(name.equals(itb.getName()));
ptmControl.verify();
}
/**
* @return a TransactionStatus object configured for a new transaction
*/
private TransactionStatus transactionStatusForNewTransaction() {
MockControl statusControl = MockControl.createControl(TransactionStatus.class);
return (TransactionStatus) statusControl.getMock();
verify(ptm).commit(status);
}
/**
@@ -501,13 +454,10 @@ public abstract class AbstractTransactionAspectTests extends TestCase {
MapTransactionAttributeSource tas = new MapTransactionAttributeSource();
tas.register(m, txatt);
MockControl ptmControl = MockControl.createControl(PlatformTransactionManager.class);
PlatformTransactionManager ptm = (PlatformTransactionManager) ptmControl.getMock();
PlatformTransactionManager ptm = mock(PlatformTransactionManager.class);
// Expect a transaction
ptm.getTransaction(txatt);
CannotCreateTransactionException ex = new CannotCreateTransactionException("foobar", null);
ptmControl.setThrowable(ex);
ptmControl.replay();
given(ptm.getTransaction(txatt)).willThrow(ex);
TestBean tb = new TestBean() {
@Override
@@ -525,7 +475,6 @@ public abstract class AbstractTransactionAspectTests extends TestCase {
catch (CannotCreateTransactionException thrown) {
assertTrue(thrown == ex);
}
ptmControl.verify();
}
/**
@@ -542,16 +491,12 @@ public abstract class AbstractTransactionAspectTests extends TestCase {
// Method m2 = getNameMethod;
// No attributes for m2
MockControl ptmControl = MockControl.createControl(PlatformTransactionManager.class);
PlatformTransactionManager ptm = (PlatformTransactionManager) ptmControl.getMock();
PlatformTransactionManager ptm = mock(PlatformTransactionManager.class);
TransactionStatus status = transactionStatusForNewTransaction();
ptm.getTransaction(txatt);
ptmControl.setReturnValue(status);
TransactionStatus status = mock(TransactionStatus.class);
given(ptm.getTransaction(txatt)).willReturn(status);
UnexpectedRollbackException ex = new UnexpectedRollbackException("foobar", null);
ptm.commit(status);
ptmControl.setThrowable(ex);
ptmControl.replay();
willThrow(ex).given(ptm).commit(status);
TestBean tb = new TestBean();
ITestBean itb = (ITestBean) advised(tb, ptm, tas);
@@ -567,7 +512,6 @@ public abstract class AbstractTransactionAspectTests extends TestCase {
// Should have invoked target and changed name
assertTrue(itb.getName() == name);
ptmControl.verify();
}
protected void checkTransactionStatus(boolean expected) {

25
spring-tx/src/test/java/org/springframework/transaction/interceptor/BeanFactoryTransactionTests.java
View File

@@ -24,23 +24,24 @@ import junit.framework.TestCase;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.easymock.MockControl;
import org.springframework.aop.support.AopUtils;
import org.springframework.aop.support.StaticMethodMatcherPointcut;
import org.springframework.aop.target.HotSwappableTargetSource;
import org.springframework.tests.sample.beans.DerivedTestBean;
import org.springframework.beans.FatalBeanException;
import org.springframework.tests.sample.beans.ITestBean;
import org.springframework.tests.sample.beans.TestBean;
import org.springframework.tests.transaction.CallCountingTransactionManager;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.core.io.ClassPathResource;
import org.springframework.tests.sample.beans.DerivedTestBean;
import org.springframework.tests.sample.beans.ITestBean;
import org.springframework.tests.sample.beans.TestBean;
import org.springframework.tests.transaction.CallCountingTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionException;
import org.springframework.transaction.TransactionStatus;
import static org.mockito.BDDMockito.*;
/**
* Test cases for AOP transaction management.
*
@@ -116,19 +117,16 @@ public class BeanFactoryTransactionTests extends TestCase {
private void doTestGetsAreNotTransactional(final ITestBean testBean) {
// Install facade
MockControl ptmControl = MockControl.createControl(PlatformTransactionManager.class);
PlatformTransactionManager ptm = (PlatformTransactionManager) ptmControl.getMock();
// Expect no methods
ptmControl.replay();
PlatformTransactionManager ptm = mock(PlatformTransactionManager.class);
PlatformTransactionManagerFacade.delegate = ptm;
assertTrue("Age should not be " + testBean.getAge(), testBean.getAge() == 666);
// Check no calls
ptmControl.verify();
// Expect no methods
verifyZeroInteractions(ptm);
// Install facade expecting a call
MockControl statusControl = MockControl.createControl(TransactionStatus.class);
final TransactionStatus ts = (TransactionStatus) statusControl.getMock();
final TransactionStatus ts = mock(TransactionStatus.class);
ptm = new PlatformTransactionManager() {
private boolean invoked;
@Override
@@ -158,7 +156,6 @@ public class BeanFactoryTransactionTests extends TestCase {
int age = 666;
testBean.setAge(age);
assertTrue(testBean.getAge() == age);
ptmControl.verify();
}
public void testGetBeansOfTypeWithAbstract() {

25
spring-tx/src/test/java/org/springframework/transaction/jta/WebSphereUowTransactionManagerTests.java
View File

@@ -20,11 +20,7 @@ import javax.transaction.RollbackException;
import javax.transaction.Status;
import javax.transaction.UserTransaction;
import com.ibm.wsspi.uow.UOWAction;
import com.ibm.wsspi.uow.UOWException;
import com.ibm.wsspi.uow.UOWManager;
import junit.framework.TestCase;
import org.easymock.MockControl;
import org.springframework.dao.OptimisticLockingFailureException;
import org.springframework.tests.mock.jndi.ExpectedLookupTemplate;
@@ -37,6 +33,12 @@ import org.springframework.transaction.support.DefaultTransactionDefinition;
import org.springframework.transaction.support.TransactionCallback;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import com.ibm.wsspi.uow.UOWAction;
import com.ibm.wsspi.uow.UOWException;
import com.ibm.wsspi.uow.UOWManager;
import static org.mockito.BDDMockito.*;
/**
* @author Juergen Hoeller
*/
@@ -64,17 +66,8 @@ public class WebSphereUowTransactionManagerTests extends TestCase {
}
public void testUowManagerAndUserTransactionFoundInJndi() throws Exception {
MockControl utControl = MockControl.createControl(UserTransaction.class);
UserTransaction ut = (UserTransaction) utControl.getMock();
ut.getStatus();
utControl.setReturnValue(Status.STATUS_NO_TRANSACTION, 1);
ut.getStatus();
utControl.setReturnValue(Status.STATUS_ACTIVE, 2);
ut.begin();
utControl.setVoidCallable(1);
ut.commit();
utControl.setVoidCallable(1);
utControl.replay();
UserTransaction ut = mock(UserTransaction.class);
given(ut.getStatus()).willReturn( Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE, Status.STATUS_ACTIVE);
MockUOWManager manager = new MockUOWManager();
ExpectedLookupTemplate jndiTemplate = new ExpectedLookupTemplate();
@@ -97,6 +90,8 @@ public class WebSphereUowTransactionManagerTests extends TestCase {
assertEquals(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION, manager.getUOWType());
assertFalse(manager.getJoined());
assertFalse(manager.getRollbackOnly());
verify(ut).begin();
verify(ut).commit();
}
public void testPropagationMandatoryFailsInCaseOfNoExistingTransaction() {

10
spring-tx/src/test/java/org/springframework/transaction/support/JtaTransactionManagerSerializationTests.java
View File

@@ -16,8 +16,6 @@
package org.springframework.transaction.support;
import static org.easymock.EasyMock.createMock;
import javax.transaction.TransactionManager;
import javax.transaction.UserTransaction;
@@ -27,15 +25,17 @@ import org.springframework.tests.mock.jndi.SimpleNamingContextBuilder;
import org.springframework.transaction.jta.JtaTransactionManager;
import org.springframework.util.SerializationTestUtils;
import static org.mockito.BDDMockito.*;
/**
* @author Rod Johnson
*/
public class JtaTransactionManagerSerializationTests extends TestCase {
public void testSerializable() throws Exception {
UserTransaction ut1 = createMock(UserTransaction.class);
UserTransaction ut2 = createMock(UserTransaction.class);
TransactionManager tm = createMock(TransactionManager.class);
UserTransaction ut1 = mock(UserTransaction.class);
UserTransaction ut2 = mock(UserTransaction.class);
TransactionManager tm = mock(TransactionManager.class);
JtaTransactionManager jtam = new JtaTransactionManager();
jtam.setUserTransaction(ut1);