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

Replace EasyMock with Mockito

Browse Source 
Issue: SPR-10126
This commit is contained in:
Phillip Webb
2013-03-04 19:46:15 -08:00
parent a399b13354
commit 05765d7520
180 changed files with 2329 additions and 4272 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);