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

migration from EasyMock to Mockito

Browse Source
This commit is contained in:
Will Schipp
2013-02-06 13:45:18 -05:00
committed by Dave Syer
parent a06f4ad389
commit 7e1e66d677
78 changed files with 772 additions and 1279 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/amqp/AmqpItemReaderTests.java
View File

@@ -16,7 +16,9 @@
package org.springframework.batch.item.amqp;
import org.easymock.classextension.EasyMock;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import org.junit.Test;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.amqp.core.Message;
@@ -31,6 +33,7 @@ import static org.junit.Assert.fail;
* </p>
*
* @author Chris Schaefer
* @author Will Schipp
*/
public class AmqpItemReaderTests {
@Test(expected = IllegalArgumentException.class)
@@ -40,51 +43,44 @@ public class AmqpItemReaderTests {
@Test
public void testNoItemType() {
final AmqpTemplate amqpTemplate = EasyMock.createMock(AmqpTemplate.class);
EasyMock.expect(amqpTemplate.receiveAndConvert()).andReturn("foo");
EasyMock.replay(amqpTemplate);
final AmqpTemplate amqpTemplate = mock(AmqpTemplate.class);
when(amqpTemplate.receiveAndConvert()).thenReturn("foo");
final AmqpItemReader<String> amqpItemReader = new AmqpItemReader<String>(amqpTemplate);
assertEquals("foo", amqpItemReader.read());
EasyMock.verify(amqpTemplate);
}
@Test
public void testNonMessageItemType() {
final AmqpTemplate amqpTemplate = EasyMock.createMock(AmqpTemplate.class);
EasyMock.expect(amqpTemplate.receiveAndConvert()).andReturn("foo");
EasyMock.replay(amqpTemplate);
final AmqpTemplate amqpTemplate = mock(AmqpTemplate.class);
when(amqpTemplate.receiveAndConvert()).thenReturn("foo");
final AmqpItemReader<String> amqpItemReader = new AmqpItemReader<String>(amqpTemplate);
amqpItemReader.setItemType(String.class);
assertEquals("foo", amqpItemReader.read());
EasyMock.verify(amqpTemplate);
}
@Test
public void testMessageItemType() {
final AmqpTemplate amqpTemplate = EasyMock.createMock(AmqpTemplate.class);
final Message message = EasyMock.createMock(Message.class);
final AmqpTemplate amqpTemplate = mock(AmqpTemplate.class);
final Message message = mock(Message.class);
EasyMock.expect(amqpTemplate.receive()).andReturn(message);
EasyMock.replay(amqpTemplate, message);
when(amqpTemplate.receive()).thenReturn(message);
final AmqpItemReader<Message> amqpItemReader = new AmqpItemReader<Message>(amqpTemplate);
amqpItemReader.setItemType(Message.class);
assertEquals(message, amqpItemReader.read());
EasyMock.verify(amqpTemplate);
}
@Test
public void testTypeMismatch() {
final AmqpTemplate amqpTemplate = EasyMock.createMock(AmqpTemplate.class);
final AmqpTemplate amqpTemplate = mock(AmqpTemplate.class);
EasyMock.expect(amqpTemplate.receiveAndConvert()).andReturn("foo");
EasyMock.replay(amqpTemplate);
when(amqpTemplate.receiveAndConvert()).thenReturn("foo");
final AmqpItemReader<Integer> amqpItemReader = new AmqpItemReader<Integer>(amqpTemplate);
amqpItemReader.setItemType(Integer.class);
@@ -96,12 +92,11 @@ public class AmqpItemReaderTests {
assertTrue(e.getMessage().contains("wrong type"));
}
EasyMock.verify(amqpTemplate);
}
@Test(expected = IllegalArgumentException.class)
public void testNullItemType() {
final AmqpTemplate amqpTemplate = EasyMock.createMock(AmqpTemplate.class);
final AmqpTemplate amqpTemplate = mock(AmqpTemplate.class);
final AmqpItemReader<String> amqpItemReader = new AmqpItemReader<String>(amqpTemplate);
amqpItemReader.setItemType(null);

12
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/amqp/AmqpItemWriterTests.java
View File

@@ -16,7 +16,8 @@
package org.springframework.batch.item.amqp;
import org.easymock.EasyMock;
import static org.mockito.Mockito.mock;
import org.junit.Test;
import org.springframework.amqp.core.AmqpTemplate;
@@ -28,6 +29,7 @@ import java.util.Arrays;
* </p>
*
* @author Chris Schaefer
* @author Will Schipp
*/
public class AmqpItemWriterTests {
@Test(expected = IllegalArgumentException.class)
@@ -37,20 +39,14 @@ public class AmqpItemWriterTests {
@Test
public void voidTestWrite() throws Exception {
AmqpTemplate amqpTemplate = EasyMock.createMock(AmqpTemplate.class);
AmqpTemplate amqpTemplate = mock(AmqpTemplate.class);
amqpTemplate.convertAndSend("foo");
EasyMock.expectLastCall();
amqpTemplate.convertAndSend("bar");
EasyMock.expectLastCall();
EasyMock.replay(amqpTemplate);
AmqpItemWriter<String> amqpItemWriter = new AmqpItemWriter<String>(amqpTemplate);
amqpItemWriter.write(Arrays.asList("foo", "bar"));
EasyMock.verify(amqpTemplate);
}
}

107
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/database/ExtendedConnectionDataSourceProxyTests.java
View File

@@ -1,9 +1,7 @@
package org.springframework.batch.item.database;
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.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotSame;
@@ -38,22 +36,19 @@ public class ExtendedConnectionDataSourceProxyTests {
@Test
public void testOperationWithDataSourceUtils() throws SQLException {
Connection con = createMock(Connection.class);
DataSource ds = createMock(DataSource.class);
Connection con = mock(Connection.class);
DataSource ds = mock(DataSource.class);
expect(ds.getConnection()).andReturn(con); // con1
when(ds.getConnection()).thenReturn(con); // con1
con.close();
expect(ds.getConnection()).andReturn(con); // con2
when(ds.getConnection()).thenReturn(con); // con2
con.close();
expect(ds.getConnection()).andReturn(con); // con3
when(ds.getConnection()).thenReturn(con); // con3
con.close(); // con3
expect(ds.getConnection()).andReturn(con); // con4
when(ds.getConnection()).thenReturn(con); // con4
con.close(); // con4
replay(ds);
replay(con);
final ExtendedConnectionDataSourceProxy csds = new ExtendedConnectionDataSourceProxy(ds);
Connection con1 = csds.getConnection();
@@ -83,23 +78,19 @@ public class ExtendedConnectionDataSourceProxyTests {
assertTrue("should be able to close connection", csds.shouldClose(con4));
con4.close();
verify(ds);
verify(con);
}
@Test
public void testOperationWithDirectCloseCall() throws SQLException {
Connection con = createMock(Connection.class);
DataSource ds = createMock(DataSource.class);
Connection con = mock(Connection.class);
DataSource ds = mock(DataSource.class);
expect(ds.getConnection()).andReturn(con); // con1
when(ds.getConnection()).thenReturn(con); // con1
con.close();
expect(ds.getConnection()).andReturn(con); // con2
when(ds.getConnection()).thenReturn(con); // con2
con.close();
replay(ds);
replay(con);
final ExtendedConnectionDataSourceProxy csds = new ExtendedConnectionDataSourceProxy(ds);
@@ -120,72 +111,66 @@ public class ExtendedConnectionDataSourceProxyTests {
assertTrue("should be able to close connection", csds.shouldClose(con2));
con2.close();
verify(ds);
verify(con);
}
@Test
public void testSupressOfCloseWithJdbcTemplate() throws Exception {
Connection con = createMock(Connection.class);
DataSource ds = createMock(DataSource.class);
Statement stmt = createMock(Statement.class);
ResultSet rs = createMock(ResultSet.class);
Connection con = mock(Connection.class);
DataSource ds = mock(DataSource.class);
Statement stmt = mock(Statement.class);
ResultSet rs = mock(ResultSet.class);
// open and start suppressing close
expect(ds.getConnection()).andReturn(con);
when(ds.getConnection()).thenReturn(con);
// transaction 1
expect(con.getAutoCommit()).andReturn(false);
expect(con.createStatement()).andReturn(stmt);
expect(stmt.executeQuery("select baz from bar")).andReturn(rs);
expect(rs.next()).andReturn(false);
expect(con.createStatement()).andReturn(stmt);
expect(stmt.executeQuery("select foo from bar")).andReturn(rs);
expect(rs.next()).andReturn(false);
when(con.getAutoCommit()).thenReturn(false);
when(con.createStatement()).thenReturn(stmt);
when(stmt.executeQuery("select baz from bar")).thenReturn(rs);
when(rs.next()).thenReturn(false);
when(con.createStatement()).thenReturn(stmt);
when(stmt.executeQuery("select foo from bar")).thenReturn(rs);
when(rs.next()).thenReturn(false);
con.commit();
// transaction 2
expect(con.getAutoCommit()).andReturn(false);
expect(con.createStatement()).andReturn(stmt);
expect(stmt.executeQuery("select ham from foo")).andReturn(rs);
expect(rs.next()).andReturn(false);
when(con.getAutoCommit()).thenReturn(false);
when(con.createStatement()).thenReturn(stmt);
when(stmt.executeQuery("select ham from foo")).thenReturn(rs);
when(rs.next()).thenReturn(false);
// REQUIRES_NEW transaction
expect(ds.getConnection()).andReturn(con);
expect(con.getAutoCommit()).andReturn(false);
expect(con.createStatement()).andReturn(stmt);
expect(stmt.executeQuery("select 1 from eggs")).andReturn(rs);
expect(rs.next()).andReturn(false);
when(ds.getConnection()).thenReturn(con);
when(con.getAutoCommit()).thenReturn(false);
when(con.createStatement()).thenReturn(stmt);
when(stmt.executeQuery("select 1 from eggs")).thenReturn(rs);
when(rs.next()).thenReturn(false);
con.commit();
con.close();
// resume transaction 2
expect(con.createStatement()).andReturn(stmt);
expect(stmt.executeQuery("select more, ham from foo")).andReturn(rs);
expect(rs.next()).andReturn(false);
when(con.createStatement()).thenReturn(stmt);
when(stmt.executeQuery("select more, ham from foo")).thenReturn(rs);
when(rs.next()).thenReturn(false);
con.commit();
// transaction 3
expect(con.getAutoCommit()).andReturn(false);
expect(con.createStatement()).andReturn(stmt);
expect(stmt.executeQuery("select spam from ham")).andReturn(rs);
expect(rs.next()).andReturn(false);
when(con.getAutoCommit()).thenReturn(false);
when(con.createStatement()).thenReturn(stmt);
when(stmt.executeQuery("select spam from ham")).thenReturn(rs);
when(rs.next()).thenReturn(false);
con.commit();
// stop suppressing close and close
con.close();
// standalone query
expect(ds.getConnection()).andReturn(con);
expect(con.createStatement()).andReturn(stmt);
expect(stmt.executeQuery("select egg from bar")).andReturn(rs);
expect(rs.next()).andReturn(false);
when(ds.getConnection()).thenReturn(con);
when(con.createStatement()).thenReturn(stmt);
when(stmt.executeQuery("select egg from bar")).thenReturn(rs);
when(rs.next()).thenReturn(false);
con.close();
replay(rs);
replay(stmt);
replay(con);
replay(ds);
final ExtendedConnectionDataSourceProxy csds = new ExtendedConnectionDataSourceProxy();
csds.setDataSource(ds);
@@ -231,10 +216,6 @@ public class ExtendedConnectionDataSourceProxyTests {
DataSourceUtils.releaseConnection(connection, csds);
template.queryForList("select egg from bar");
verify(rs);
verify(stmt);
verify(con);
verify(ds);
}
@Test(expected = IllegalArgumentException.class)

29
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/database/HibernateCursorItemReaderStatefulIntegrationTests.java
View File

@@ -1,10 +1,7 @@
package org.springframework.batch.item.database;
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.createNiceMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.verify;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import org.hibernate.Query;
import org.hibernate.Session;
@@ -17,6 +14,7 @@ import org.springframework.batch.item.sample.Foo;
* Tests for {@link HibernateCursorItemReader} using standard hibernate {@link Session}.
*
* @author Robert Kasanicky
* @author Will Schipp
*/
public class HibernateCursorItemReaderStatefulIntegrationTests extends AbstractHibernateCursorItemReaderIntegrationTests {
@@ -29,28 +27,21 @@ public class HibernateCursorItemReaderStatefulIntegrationTests extends AbstractH
@Test
public void testStatefulClose(){
SessionFactory sessionFactory = createMock(SessionFactory.class);
Session session = createMock(Session.class);
Query scrollableResults = createNiceMock(Query.class);
SessionFactory sessionFactory = mock(SessionFactory.class);
Session session = mock(Session.class);
Query scrollableResults = mock(Query.class);
HibernateCursorItemReader<Foo> itemReader = new HibernateCursorItemReader<Foo>();
itemReader.setSessionFactory(sessionFactory);
itemReader.setQueryString("testQuery");
itemReader.setUseStatelessSession(false);
expect(sessionFactory.openSession()).andReturn(session);
expect(session.createQuery("testQuery")).andReturn(scrollableResults);
expect(scrollableResults.setFetchSize(0)).andReturn(scrollableResults);
expect(session.close()).andReturn(null);
replay(sessionFactory);
replay(session);
replay(scrollableResults);
when(sessionFactory.openSession()).thenReturn(session);
when(session.createQuery("testQuery")).thenReturn(scrollableResults);
when(scrollableResults.setFetchSize(0)).thenReturn(scrollableResults);
when(session.close()).thenReturn(null);
itemReader.open(new ExecutionContext());
itemReader.close();
verify(sessionFactory);
verify(session);
}
}

22
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/database/HibernateItemReaderHelperTests.java
View File

@@ -16,10 +16,13 @@
package org.springframework.batch.item.database;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import org.easymock.EasyMock;
import org.hibernate.SessionFactory;
import org.hibernate.StatelessSession;
import org.junit.Test;
@@ -28,37 +31,34 @@ import org.springframework.test.util.ReflectionTestUtils;
/**
* @author Dave Syer
* @author Will Schipp
*
*/
public class HibernateItemReaderHelperTests {
private HibernateItemReaderHelper<String> helper = new HibernateItemReaderHelper<String>();
private SessionFactory sessionFactory = EasyMock.createMock(SessionFactory.class);
private SessionFactory sessionFactory = mock(SessionFactory.class);
@Test
public void testOneSessionForAllPages() throws Exception {
StatelessSession session = EasyMock.createNiceMock(StatelessSession.class);
EasyMock.expect(sessionFactory.openStatelessSession()).andReturn(session);
EasyMock.replay(sessionFactory, session);
StatelessSession session = mock(StatelessSession.class);
when(sessionFactory.openStatelessSession()).thenReturn(session);
helper.setSessionFactory(sessionFactory);
helper.createQuery();
// Multiple calls to createQuery only creates one session
helper.createQuery();
EasyMock.verify(sessionFactory, session);
}
@Test
public void testSessionReset() throws Exception {
StatelessSession session = EasyMock.createNiceMock(StatelessSession.class);
EasyMock.expect(sessionFactory.openStatelessSession()).andReturn(session);
EasyMock.replay(sessionFactory, session);
StatelessSession session = mock(StatelessSession.class);
when(sessionFactory.openStatelessSession()).thenReturn(session);
helper.setSessionFactory(sessionFactory);
@@ -67,8 +67,6 @@ public class HibernateItemReaderHelperTests {
helper.close();
assertNull(ReflectionTestUtils.getField(helper, "statelessSession"));
EasyMock.verify(sessionFactory, session);
}

41
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/database/HibernateItemWriterTests.java
View File

@@ -15,10 +15,8 @@
*/
package org.springframework.batch.item.database;
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.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
@@ -37,6 +35,7 @@ import org.springframework.orm.hibernate3.HibernateOperations;
* @author Dave Syer
* @author Thomas Risberg
* @author Michael Minella
* @author Will Schipp
*/
public class HibernateItemWriterTests {
@@ -50,9 +49,9 @@ public class HibernateItemWriterTests {
@Before
public void setUp() throws Exception {
writer = new HibernateItemWriter<Object>();
ht = createMock("ht", HibernateOperations.class);
factory = createMock(SessionFactory.class);
currentSession = createMock(Session.class);
ht = mock(HibernateOperations.class,"ht");
factory = mock(SessionFactory.class);
currentSession = mock(Session.class);
}
/**
@@ -89,25 +88,22 @@ public class HibernateItemWriterTests {
@Test
public void testWriteAndFlushSunnyDayHibernate3() throws Exception {
writer.setHibernateTemplate(ht);
expect(ht.contains("foo")).andReturn(true);
expect(ht.contains("bar")).andReturn(false);
when(ht.contains("foo")).thenReturn(true);
when(ht.contains("bar")).thenReturn(false);
ht.saveOrUpdate("bar");
ht.flush();
ht.clear();
replay(ht);
List<String> items = Arrays.asList(new String[] { "foo", "bar" });
writer.write(items);
verify(ht);
}
@Test
public void testWriteAndFlushWithFailureHibernate3() throws Exception {
writer.setHibernateTemplate(ht);
final RuntimeException ex = new RuntimeException("ERROR");
expect(ht.contains("foo")).andThrow(ex);
replay(ht);
when(ht.contains("foo")).thenThrow(ex);
try {
writer.write(Collections.singletonList("foo"));
@@ -117,25 +113,20 @@ public class HibernateItemWriterTests {
assertEquals("ERROR", e.getMessage());
}
verify(ht);
}
@Test
public void testWriteAndFlushSunnyDayHibernate4() throws Exception {
writer.setSessionFactory(factory);
expect(factory.getCurrentSession()).andReturn(currentSession).times(3);
expect(currentSession.contains("foo")).andReturn(true);
expect(currentSession.contains("bar")).andReturn(false);
when(factory.getCurrentSession()).thenReturn(currentSession);
when(currentSession.contains("foo")).thenReturn(true);
when(currentSession.contains("bar")).thenReturn(false);
currentSession.saveOrUpdate("bar");
currentSession.flush();
currentSession.clear();
replay(factory, currentSession);
List<String> items = Arrays.asList(new String[] { "foo", "bar" });
writer.write(items);
verify(factory, currentSession);
}
@Test
@@ -143,10 +134,8 @@ public class HibernateItemWriterTests {
writer.setSessionFactory(factory);
final RuntimeException ex = new RuntimeException("ERROR");
expect(factory.getCurrentSession()).andReturn(currentSession);
expect(currentSession.contains("foo")).andThrow(ex);
replay(factory, currentSession);
when(factory.getCurrentSession()).thenReturn(currentSession);
when(currentSession.contains("foo")).thenThrow(ex);
try {
writer.write(Collections.singletonList("foo"));
@@ -155,7 +144,5 @@ public class HibernateItemWriterTests {
catch (RuntimeException e) {
assertEquals("ERROR", e.getMessage());
}
verify(factory, currentSession);
}
}

48
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/database/IbatisBatchItemWriterTests.java
View File

@@ -16,7 +16,8 @@
package org.springframework.batch.item.database;
import static org.junit.Assert.*;
import static org.easymock.EasyMock.*;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.Collections;
import java.util.List;
@@ -34,6 +35,7 @@ import com.ibatis.sqlmap.engine.execution.BatchResult;
/**
* @author Thomas Risberg
* @author Will Schipp
*/
public class IbatisBatchItemWriterTests {
@@ -94,8 +96,8 @@ public class IbatisBatchItemWriterTests {
@Before
public void setUp() throws Exception {
smc = createMock(SqlMapClient.class);
ds = createNiceMock(DataSource.class);
smc = mock(SqlMapClient.class);
ds = mock(DataSource.class);
smct = new SqlMapClientTemplate(ds, smc);
writer.setStatementId(statementId);
writer.setSqlMapClientTemplate(smct);
@@ -136,37 +138,31 @@ public class IbatisBatchItemWriterTests {
@Test
public void testWriteAndFlush() throws Exception {
SqlMapSession sms = createMock(SqlMapSession.class);
expect(smc.openSession()).andReturn(sms);
SqlMapSession sms = mock(SqlMapSession.class);
when(smc.openSession()).thenReturn(sms);
sms.close();
expect(sms.getCurrentConnection()).andReturn(null);
when(sms.getCurrentConnection()).thenReturn(null);
sms.setUserConnection(null);
sms.startBatch();
expect(sms.update("updateFoo", new Foo("bar"))).andReturn(-2);
when(sms.update("updateFoo", new Foo("bar"))).thenReturn(-2);
List<BatchResult> results = Collections.singletonList(new BatchResult("updateFoo", "update foo"));
results.get(0).setUpdateCounts(new int[] {1});
expect(sms.executeBatchDetailed()).andReturn(results);
replay(sms);
replay(smc);
when(sms.executeBatchDetailed()).thenReturn(results);
writer.write(Collections.singletonList(new Foo("bar")));
verify(sms);
verify(smc);
}
@Test
public void testWriteAndFlushWithEmptyUpdate() throws Exception {
SqlMapSession sms = createMock(SqlMapSession.class);
expect(smc.openSession()).andReturn(sms);
SqlMapSession sms = mock(SqlMapSession.class);
when(smc.openSession()).thenReturn(sms);
sms.close();
expect(sms.getCurrentConnection()).andReturn(null);
when(sms.getCurrentConnection()).thenReturn(null);
sms.setUserConnection(null);
sms.startBatch();
expect(sms.update("updateFoo", new Foo("bar"))).andReturn(1);
when(sms.update("updateFoo", new Foo("bar"))).thenReturn(1);
List<BatchResult> results = Collections.singletonList(new BatchResult("updateFoo", "update foo"));
results.get(0).setUpdateCounts(new int[] {0});
expect(sms.executeBatchDetailed()).andReturn(results);
replay(sms);
replay(smc);
when(sms.executeBatchDetailed()).thenReturn(results);
try {
writer.write(Collections.singletonList(new Foo("bar")));
fail("Expected EmptyResultDataAccessException");
@@ -176,22 +172,18 @@ public class IbatisBatchItemWriterTests {
String message = e.getMessage();
assertTrue("Wrong message: " + message, message.indexOf("did not update") >= 0);
}
verify(sms);
verify(smc);
}
@Test
public void testWriteAndFlushWithFailure() throws Exception {
final RuntimeException ex = new RuntimeException("ERROR");
SqlMapSession sms = createMock(SqlMapSession.class);
expect(smc.openSession()).andReturn(sms);
SqlMapSession sms = mock(SqlMapSession.class);
when(smc.openSession()).thenReturn(sms);
sms.close();
expect(sms.getCurrentConnection()).andReturn(null);
when(sms.getCurrentConnection()).thenReturn(null);
sms.setUserConnection(null);
sms.startBatch();
expect(sms.update("updateFoo", new Foo("bar"))).andThrow(ex);
replay(sms);
replay(smc);
when(sms.update("updateFoo", new Foo("bar"))).thenThrow(ex);
try {
writer.write(Collections.singletonList(new Foo("bar")));
fail("Expected RuntimeException");
@@ -199,8 +191,6 @@ public class IbatisBatchItemWriterTests {
catch (RuntimeException e) {
assertEquals("ERROR", e.getMessage());
}
verify(sms);
verify(smc);
}
}

19
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/database/JdbcBatchItemWriterClassicTests.java
View File

@@ -16,7 +16,8 @@
package org.springframework.batch.item.database;
import static org.junit.Assert.*;
import static org.easymock.EasyMock.*;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.sql.PreparedStatement;
import java.sql.SQLException;
@@ -36,6 +37,7 @@ import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
/**
* @author Dave Syer
* @author Thomas Risberg
* @author Will Schipp
*/
public class JdbcBatchItemWriterClassicTests {
@@ -49,7 +51,7 @@ public class JdbcBatchItemWriterClassicTests {
@Before
public void setUp() throws Exception {
ps = createMock(PreparedStatement.class);
ps = mock(PreparedStatement.class);
jdbcTemplate = new JdbcTemplate() {
@Override
public Object execute(String sql, PreparedStatementCallback action) throws DataAccessException {
@@ -125,9 +127,7 @@ public class JdbcBatchItemWriterClassicTests {
@Test
public void testWriteAndFlush() throws Exception {
ps.addBatch();
expectLastCall();
expect(ps.executeBatch()).andReturn(new int[] { 123 });
replay(ps);
when(ps.executeBatch()).thenReturn(new int[] { 123 });
writer.write(Collections.singletonList("bar"));
assertEquals(2, list.size());
assertTrue(list.contains("SQL"));
@@ -136,9 +136,7 @@ public class JdbcBatchItemWriterClassicTests {
@Test
public void testWriteAndFlushWithEmptyUpdate() throws Exception {
ps.addBatch();
expectLastCall();
expect(ps.executeBatch()).andReturn(new int[] { 0 });
replay(ps);
when(ps.executeBatch()).thenReturn(new int[] { 0 });
try {
writer.write(Collections.singletonList("bar"));
fail("Expected EmptyResultDataAccessException");
@@ -163,9 +161,7 @@ public class JdbcBatchItemWriterClassicTests {
}
});
ps.addBatch();
expectLastCall().times(1);
expect(ps.executeBatch()).andReturn(new int[] { 123 });
replay(ps);
when(ps.executeBatch()).thenReturn(new int[] { 123 });
try {
writer.write(Collections.singletonList("foo"));
fail("Expected RuntimeException");
@@ -181,7 +177,6 @@ public class JdbcBatchItemWriterClassicTests {
}
});
writer.write(Collections.singletonList("foo"));
verify(ps);
assertEquals(4, list.size());
assertTrue(list.contains("SQL"));
assertTrue(list.contains("foo"));

59
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/database/JdbcBatchItemWriterNamedParameterTests.java
View File

@@ -15,22 +15,28 @@
*/
package org.springframework.batch.item.database;
import static org.junit.Assert.*;
import static org.easymock.EasyMock.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.argThat;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.Collections;
import org.easymock.EasyMock;
import org.easymock.IArgumentMatcher;
import org.hamcrest.BaseMatcher;
import org.hamcrest.Description;
import org.junit.Before;
import org.junit.Test;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
/**
* @author Thomas Risberg
* @author Will Schipp
*/
public class JdbcBatchItemWriterNamedParameterTests {
@@ -70,7 +76,7 @@ public class JdbcBatchItemWriterNamedParameterTests {
@Before
public void setUp() throws Exception {
namedParameterJdbcOperations = createMock(NamedParameterJdbcOperations.class);
namedParameterJdbcOperations = mock(NamedParameterJdbcOperations.class);
writer.setSql(sql);
writer.setJdbcTemplate(namedParameterJdbcOperations);
writer.setItemSqlParameterSourceProvider(
@@ -123,20 +129,17 @@ public class JdbcBatchItemWriterNamedParameterTests {
@Test
public void testWriteAndFlush() throws Exception {
expect(namedParameterJdbcOperations.batchUpdate(eq(sql),
when(namedParameterJdbcOperations.batchUpdate(eq(sql),
eqSqlParameterSourceArray(new SqlParameterSource[] {new BeanPropertySqlParameterSource(new Foo("bar"))})))
.andReturn(new int[] {1});
replay(namedParameterJdbcOperations);
.thenReturn(new int[] {1});
writer.write(Collections.singletonList(new Foo("bar")));
verify(namedParameterJdbcOperations);
}
@Test
public void testWriteAndFlushWithEmptyUpdate() throws Exception {
expect(namedParameterJdbcOperations.batchUpdate(eq(sql),
when(namedParameterJdbcOperations.batchUpdate(eq(sql),
eqSqlParameterSourceArray(new SqlParameterSource[] {new BeanPropertySqlParameterSource(new Foo("bar"))})))
.andReturn(new int[] {0});
replay(namedParameterJdbcOperations);
.thenReturn(new int[] {0});
try {
writer.write(Collections.singletonList(new Foo("bar")));
fail("Expected EmptyResultDataAccessException");
@@ -146,16 +149,14 @@ public class JdbcBatchItemWriterNamedParameterTests {
String message = e.getMessage();
assertTrue("Wrong message: " + message, message.indexOf("did not update") >= 0);
}
verify(namedParameterJdbcOperations);
}
@Test
public void testWriteAndFlushWithFailure() throws Exception {
final RuntimeException ex = new RuntimeException("ERROR");
expect(namedParameterJdbcOperations.batchUpdate(eq(sql),
when(namedParameterJdbcOperations.batchUpdate(eq(sql),
eqSqlParameterSourceArray(new SqlParameterSource[] {new BeanPropertySqlParameterSource(new Foo("bar"))})))
.andThrow(ex);
replay(namedParameterJdbcOperations);
.thenThrow(ex);
try {
writer.write(Collections.singletonList(new Foo("bar")));
fail("Expected RuntimeException");
@@ -163,15 +164,14 @@ public class JdbcBatchItemWriterNamedParameterTests {
catch (RuntimeException e) {
assertEquals("ERROR", e.getMessage());
}
verify(namedParameterJdbcOperations);
}
public static SqlParameterSource[] eqSqlParameterSourceArray(SqlParameterSource[] in) {
EasyMock.reportMatcher(new SqlParameterSourceArrayEquals(in));
argThat(new SqlParameterSourceArrayEquals(in));
return null;
}
public static class SqlParameterSourceArrayEquals implements IArgumentMatcher {
public static class SqlParameterSourceArrayEquals extends BaseMatcher<SqlParameterSource[]> {
private SqlParameterSource[] expected;
public SqlParameterSourceArrayEquals(SqlParameterSource[] expected) {
@@ -195,14 +195,15 @@ public class JdbcBatchItemWriterNamedParameterTests {
return true;
}
@Override
public void appendTo(StringBuffer buffer) {
buffer.append("eqSqlParameterSourceArray(");
buffer.append(expected.getClass().getName());
buffer.append(" with length \"");
buffer.append(expected.length);
buffer.append("\")");
}
}
@Override
public void describeTo(Description description) {
description.appendText("eqSqlParameterSourceArray(");
description.appendText(expected.getClass().getName());
description.appendText(" with length \"");
description.appendValue(expected.length);
description.appendText("\")");
}
}
}

41
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/database/JdbcCursorItemReaderConfigTests.java
View File

@@ -1,10 +1,7 @@
package org.springframework.batch.item.database;
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.createNiceMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.verify;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.sql.Connection;
import java.sql.PreparedStatement;
@@ -30,16 +27,15 @@ public class JdbcCursorItemReaderConfigTests {
*/
@Test
public void testUsesCurrentTransaction() throws Exception {
DataSource ds = createMock(DataSource.class);
Connection con = createMock(Connection.class);
expect(con.getAutoCommit()).andReturn(false);
PreparedStatement ps = createNiceMock(PreparedStatement.class);
expect(con.prepareStatement("select foo from bar", ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY,
ResultSet.HOLD_CURSORS_OVER_COMMIT)).andReturn(ps);
expect(ds.getConnection()).andReturn(con);
expect(ds.getConnection()).andReturn(con);
DataSource ds = mock(DataSource.class);
Connection con = mock(Connection.class);
when(con.getAutoCommit()).thenReturn(false);
PreparedStatement ps = mock(PreparedStatement.class);
when(con.prepareStatement("select foo from bar", ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY,
ResultSet.HOLD_CURSORS_OVER_COMMIT)).thenReturn(ps);
when(ds.getConnection()).thenReturn(con);
when(ds.getConnection()).thenReturn(con);
con.commit();
replay(con, ds, ps);
PlatformTransactionManager tm = new DataSourceTransactionManager(ds);
TransactionTemplate tt = new TransactionTemplate(tm);
final JdbcCursorItemReader<String> reader = new JdbcCursorItemReader<String>();
@@ -56,7 +52,6 @@ public class JdbcCursorItemReaderConfigTests {
return null;
}
});
verify(ds);
}
/*
@@ -65,15 +60,14 @@ public class JdbcCursorItemReaderConfigTests {
@Test
public void testUsesItsOwnTransaction() throws Exception {
DataSource ds = createMock(DataSource.class);
Connection con = createMock(Connection.class);
expect(con.getAutoCommit()).andReturn(false);
PreparedStatement ps = createNiceMock(PreparedStatement.class);
expect(con.prepareStatement("select foo from bar", ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY)).andReturn(ps);
expect(ds.getConnection()).andReturn(con);
expect(ds.getConnection()).andReturn(con);
DataSource ds = mock(DataSource.class);
Connection con = mock(Connection.class);
when(con.getAutoCommit()).thenReturn(false);
PreparedStatement ps = mock(PreparedStatement.class);
when(con.prepareStatement("select foo from bar", ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY)).thenReturn(ps);
when(ds.getConnection()).thenReturn(con);
when(ds.getConnection()).thenReturn(con);
con.commit();
replay(con, ds, ps);
PlatformTransactionManager tm = new DataSourceTransactionManager(ds);
TransactionTemplate tt = new TransactionTemplate(tm);
final JdbcCursorItemReader<String> reader = new JdbcCursorItemReader<String>();
@@ -89,7 +83,6 @@ public class JdbcCursorItemReaderConfigTests {
return null;
}
});
verify(ds);
}
}

26
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/database/JpaItemWriterTests.java
View File

@@ -16,13 +16,11 @@
package org.springframework.batch.item.database;
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.expectLastCall;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.verify;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.Arrays;
import java.util.List;
@@ -37,6 +35,7 @@ import org.springframework.transaction.support.TransactionSynchronizationManager
/**
* @author Thomas Risberg
* @author Will Schipp
*
*/
public class JpaItemWriterTests {
@@ -51,7 +50,7 @@ public class JpaItemWriterTests {
TransactionSynchronizationManager.clearSynchronization();
}
writer = new JpaItemWriter<Object>();
emf = createMock("emf", EntityManagerFactory.class);
emf = mock(EntityManagerFactory.class,"emf");
writer.setEntityManagerFactory(emf);
}
@@ -71,38 +70,28 @@ public class JpaItemWriterTests {
@Test
public void testWriteAndFlushSunnyDay() throws Exception {
EntityManager em = createMock("em", EntityManager.class);
EntityManager em = mock(EntityManager.class,"em");
em.contains("foo");
expectLastCall().andReturn(true);
em.contains("bar");
expectLastCall().andReturn(false);
em.merge("bar");
expectLastCall().andReturn("bar");
em.flush();
replay(em);
replay(emf);
TransactionSynchronizationManager.bindResource(emf, new EntityManagerHolder(em));
List<String> items = Arrays.asList(new String[] { "foo", "bar" });
writer.write(items);
verify(em);
TransactionSynchronizationManager.unbindResource(emf);
}
@Test
public void testWriteAndFlushWithFailure() throws Exception {
final RuntimeException ex = new RuntimeException("ERROR");
EntityManager em = createMock("em", EntityManager.class);
EntityManager em = mock(EntityManager.class,"em");
em.contains("foo");
expectLastCall().andReturn(true);
em.contains("bar");
expectLastCall().andReturn(false);
em.merge("bar");
expectLastCall().andThrow(ex);
replay(em);
replay(emf);
when(em).thenThrow(ex);
TransactionSynchronizationManager.bindResource(emf, new EntityManagerHolder(em));
List<String> items = Arrays.asList(new String[] { "foo", "bar" });
@@ -114,7 +103,6 @@ public class JpaItemWriterTests {
assertEquals("ERROR", e.getMessage());
}
verify(em);
TransactionSynchronizationManager.unbindResource(emf);
}

81
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/database/StoredprocedureItemReaderConfigTests.java
View File

@@ -1,10 +1,7 @@
package org.springframework.batch.item.database;
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.createNiceMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.verify;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.sql.CallableStatement;
import java.sql.Connection;
@@ -36,20 +33,19 @@ public class StoredprocedureItemReaderConfigTests {
*/
@Test
public void testUsesCurrentTransaction() throws Exception {
DataSource ds = createMock(DataSource.class);
DatabaseMetaData dmd = createNiceMock(DatabaseMetaData.class);
expect(dmd.getDatabaseProductName()).andReturn("Oracle").times(2);
Connection con = createMock(Connection.class);
expect(con.getMetaData()).andReturn(dmd);
expect(con.getMetaData()).andReturn(dmd);
expect(con.getAutoCommit()).andReturn(false);
CallableStatement cs = createNiceMock(CallableStatement.class);
expect(con.prepareCall("{call foo_bar()}", ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY,
ResultSet.HOLD_CURSORS_OVER_COMMIT)).andReturn(cs);
expect(ds.getConnection()).andReturn(con);
expect(ds.getConnection()).andReturn(con);
DataSource ds = mock(DataSource.class);
DatabaseMetaData dmd = mock(DatabaseMetaData.class);
when(dmd.getDatabaseProductName()).thenReturn("Oracle");
Connection con = mock(Connection.class);
when(con.getMetaData()).thenReturn(dmd);
when(con.getMetaData()).thenReturn(dmd);
when(con.getAutoCommit()).thenReturn(false);
CallableStatement cs = mock(CallableStatement.class);
when(con.prepareCall("{call foo_bar()}", ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY,
ResultSet.HOLD_CURSORS_OVER_COMMIT)).thenReturn(cs);
when(ds.getConnection()).thenReturn(con);
when(ds.getConnection()).thenReturn(con);
con.commit();
replay(con,dmd, ds, cs);
PlatformTransactionManager tm = new DataSourceTransactionManager(ds);
TransactionTemplate tt = new TransactionTemplate(tm);
final StoredProcedureItemReader<String> reader = new StoredProcedureItemReader<String>();
@@ -66,7 +62,6 @@ public class StoredprocedureItemReaderConfigTests {
return null;
}
});
verify(ds);
}
/*
@@ -75,19 +70,18 @@ public class StoredprocedureItemReaderConfigTests {
@Test
public void testUsesItsOwnTransaction() throws Exception {
DataSource ds = createMock(DataSource.class);
DatabaseMetaData dmd = createNiceMock(DatabaseMetaData.class);
expect(dmd.getDatabaseProductName()).andReturn("Oracle").times(2);
Connection con = createMock(Connection.class);
expect(con.getMetaData()).andReturn(dmd);
expect(con.getMetaData()).andReturn(dmd);
expect(con.getAutoCommit()).andReturn(false);
CallableStatement cs = createNiceMock(CallableStatement.class);
expect(con.prepareCall("{call foo_bar()}", ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY)).andReturn(cs);
expect(ds.getConnection()).andReturn(con);
expect(ds.getConnection()).andReturn(con);
DataSource ds = mock(DataSource.class);
DatabaseMetaData dmd = mock(DatabaseMetaData.class);
when(dmd.getDatabaseProductName()).thenReturn("Oracle");
Connection con = mock(Connection.class);
when(con.getMetaData()).thenReturn(dmd);
when(con.getMetaData()).thenReturn(dmd);
when(con.getAutoCommit()).thenReturn(false);
CallableStatement cs = mock(CallableStatement.class);
when(con.prepareCall("{call foo_bar()}", ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY)).thenReturn(cs);
when(ds.getConnection()).thenReturn(con);
when(ds.getConnection()).thenReturn(con);
con.commit();
replay(con,dmd, ds, cs);
PlatformTransactionManager tm = new DataSourceTransactionManager(ds);
TransactionTemplate tt = new TransactionTemplate(tm);
final StoredProcedureItemReader<String> reader = new StoredProcedureItemReader<String>();
@@ -103,7 +97,6 @@ public class StoredprocedureItemReaderConfigTests {
return null;
}
});
verify(ds);
}
/*
@@ -112,19 +105,18 @@ public class StoredprocedureItemReaderConfigTests {
@Test
public void testHandlesRefCursorPosition() throws Exception {
DataSource ds = createMock(DataSource.class);
DatabaseMetaData dmd = createNiceMock(DatabaseMetaData.class);
expect(dmd.getDatabaseProductName()).andReturn("Oracle").times(2);
Connection con = createMock(Connection.class);
expect(con.getMetaData()).andReturn(dmd);
expect(con.getMetaData()).andReturn(dmd);
expect(con.getAutoCommit()).andReturn(false);
CallableStatement cs = createNiceMock(CallableStatement.class);
expect(con.prepareCall("{call foo_bar(?, ?)}", ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY)).andReturn(cs);
expect(ds.getConnection()).andReturn(con);
expect(ds.getConnection()).andReturn(con);
DataSource ds = mock(DataSource.class);
DatabaseMetaData dmd = mock(DatabaseMetaData.class);
when(dmd.getDatabaseProductName()).thenReturn("Oracle");
Connection con = mock(Connection.class);
when(con.getMetaData()).thenReturn(dmd);
when(con.getMetaData()).thenReturn(dmd);
when(con.getAutoCommit()).thenReturn(false);
CallableStatement cs = mock(CallableStatement.class);
when(con.prepareCall("{call foo_bar(?, ?)}", ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY)).thenReturn(cs);
when(ds.getConnection()).thenReturn(con);
when(ds.getConnection()).thenReturn(con);
con.commit();
replay(con,dmd, ds, cs);
PlatformTransactionManager tm = new DataSourceTransactionManager(ds);
TransactionTemplate tt = new TransactionTemplate(tm);
final StoredProcedureItemReader<String> reader = new StoredProcedureItemReader<String>();
@@ -151,6 +143,5 @@ public class StoredprocedureItemReaderConfigTests {
return null;
}
});
verify(ds);
}
}

10
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/database/support/ColumnMapExecutionContextRowMapperTests.java
View File

@@ -3,7 +3,8 @@
*/
package org.springframework.batch.item.database.support;
import static org.easymock.EasyMock.*;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.sql.PreparedStatement;
import java.util.HashMap;
@@ -14,6 +15,7 @@ import junit.framework.TestCase;
/**
* @author Lucas Ward
* @author Will Schipp
*/
public class ColumnMapExecutionContextRowMapperTests extends TestCase {
@@ -27,7 +29,7 @@ public class ColumnMapExecutionContextRowMapperTests extends TestCase {
protected void setUp() throws Exception {
super.setUp();
ps = createMock(PreparedStatement.class);
ps = mock(PreparedStatement.class);
mapper = new ColumnMapItemPreparedStatementSetter();
key = new LinkedHashMap<String, Object>(2);
@@ -37,18 +39,14 @@ public class ColumnMapExecutionContextRowMapperTests extends TestCase {
public void testCreateExecutionContextFromEmptyKeys() throws Exception {
replay(ps);
mapper.setValues(new HashMap<String, Object>(), ps);
verify(ps);
}
public void testCreateSetter() throws Exception {
ps.setObject(1, Integer.valueOf(1));
ps.setObject(2, Integer.valueOf(2));
replay(ps);
mapper.setValues(key, ps);
verify(ps);
}
}

6
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/database/support/DefaultDataFieldMaxValueIncrementerFactoryTests.java
View File

@@ -19,7 +19,8 @@ import javax.sql.DataSource;
import junit.framework.TestCase;
import static org.easymock.EasyMock.*;
import static org.mockito.Mockito.mock;
import org.springframework.jdbc.support.incrementer.DB2SequenceMaxValueIncrementer;
import org.springframework.jdbc.support.incrementer.DerbyMaxValueIncrementer;
import org.springframework.jdbc.support.incrementer.HsqlMaxValueIncrementer;
@@ -32,6 +33,7 @@ import org.springframework.jdbc.support.incrementer.DB2MainframeSequenceMaxValue
/**
* @author Lucas Ward
* @author Will Schipp
*
*/
public class DefaultDataFieldMaxValueIncrementerFactoryTests extends TestCase {
@@ -45,7 +47,7 @@ public class DefaultDataFieldMaxValueIncrementerFactoryTests extends TestCase {
protected void setUp() throws Exception {
super.setUp();
DataSource dataSource = createMock(DataSource.class);
DataSource dataSource = mock(DataSource.class);
factory = new DefaultDataFieldMaxValueIncrementerFactory(dataSource);
}

43
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/database/support/DerbyPagingQueryProviderTests.java
View File

@@ -15,10 +15,8 @@
*/
package org.springframework.batch.item.database.support;
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.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
@@ -36,6 +34,7 @@ import org.springframework.dao.InvalidDataAccessResourceUsageException;
/**
* @author Thomas Risberg
* @author Michael Minella
* @author Will Schipp
*/
public class DerbyPagingQueryProviderTests extends AbstractSqlPagingQueryProviderTests {
@@ -45,32 +44,23 @@ public class DerbyPagingQueryProviderTests extends AbstractSqlPagingQueryProvide
@Test
public void testInit() throws Exception {
DataSource ds = createMock(DataSource.class);
Connection con = createMock(Connection.class);
DatabaseMetaData dmd = createMock(DatabaseMetaData.class);
expect(dmd.getDatabaseProductVersion()).andReturn("10.4.1.3");
expect(con.getMetaData()).andReturn(dmd);
expect(ds.getConnection()).andReturn(con);
replay(dmd);
replay(con);
replay(ds);
DataSource ds = mock(DataSource.class);
Connection con = mock(Connection.class);
DatabaseMetaData dmd = mock(DatabaseMetaData.class);
when(dmd.getDatabaseProductVersion()).thenReturn("10.4.1.3");
when(con.getMetaData()).thenReturn(dmd);
when(ds.getConnection()).thenReturn(con);
pagingQueryProvider.init(ds);
verify(ds);
verify(con);
verify(dmd);
}
@Test
public void testInitWithUnsupportedVErsion() throws Exception {
DataSource ds = createMock(DataSource.class);
Connection con = createMock(Connection.class);
DatabaseMetaData dmd = createMock(DatabaseMetaData.class);
expect(dmd.getDatabaseProductVersion()).andReturn("10.2.9.9");
expect(con.getMetaData()).andReturn(dmd);
expect(ds.getConnection()).andReturn(con);
replay(dmd);
replay(con);
replay(ds);
DataSource ds = mock(DataSource.class);
Connection con = mock(Connection.class);
DatabaseMetaData dmd = mock(DatabaseMetaData.class);
when(dmd.getDatabaseProductVersion()).thenReturn("10.2.9.9");
when(con.getMetaData()).thenReturn(dmd);
when(ds.getConnection()).thenReturn(con);
try {
pagingQueryProvider.init(ds);
fail();
@@ -78,9 +68,6 @@ public class DerbyPagingQueryProviderTests extends AbstractSqlPagingQueryProvide
catch (InvalidDataAccessResourceUsageException e) {
// expected
}
verify(ds);
verify(con);
verify(dmd);
}
@Test

29
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/database/support/HibernateNativeQueryProviderTests.java
View File

@@ -16,10 +16,8 @@
package org.springframework.batch.item.database.support;
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.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
@@ -31,6 +29,7 @@ import org.springframework.util.Assert;
/**
* @author Anatoly Polinsky
* @author Dave Syer
* @author Will Schipp
*/
public class HibernateNativeQueryProviderTests {
@@ -46,18 +45,15 @@ public class HibernateNativeQueryProviderTests {
String sqlQuery = "select * from T_FOOS";
hibernateQueryProvider.setSqlQuery(sqlQuery);
StatelessSession session = createMock(StatelessSession.class);
SQLQuery query = createMock(SQLQuery.class);
StatelessSession session = mock(StatelessSession.class);
SQLQuery query = mock(SQLQuery.class);
expect(session.createSQLQuery(sqlQuery)).andReturn(query);
expect(query.addEntity(Foo.class)).andReturn(query);
replay(session, query);
when(session.createSQLQuery(sqlQuery)).thenReturn(query);
when(query.addEntity(Foo.class)).thenReturn(query);
hibernateQueryProvider.setStatelessSession(session);
Assert.notNull(hibernateQueryProvider.createQuery());
verify(session, query);
}
@Test
@@ -65,18 +61,15 @@ public class HibernateNativeQueryProviderTests {
String sqlQuery = "select * from T_FOOS";
hibernateQueryProvider.setSqlQuery(sqlQuery);
Session session = createMock(Session.class);
SQLQuery query = createMock(SQLQuery.class);
Session session = mock(Session.class);
SQLQuery query = mock(SQLQuery.class);
expect(session.createSQLQuery(sqlQuery)).andReturn(query);
expect(query.addEntity(Foo.class)).andReturn(query);
replay(session, query);
when(session.createSQLQuery(sqlQuery)).thenReturn(query);
when(query.addEntity(Foo.class)).thenReturn(query);
hibernateQueryProvider.setSession(session);
Assert.notNull(hibernateQueryProvider.createQuery());
verify(session, query);
}
private static class Foo {

17
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/database/support/JpaNativeQueryProviderTests.java
View File

@@ -16,10 +16,8 @@
package org.springframework.batch.item.database.support;
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.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import javax.persistence.EntityManager;
import javax.persistence.Query;
@@ -32,6 +30,7 @@ import org.springframework.util.Assert;
/**
* @author Anatoly Polinsky
* @author Dave Syer
* @author Will Schipp
*/
public class JpaNativeQueryProviderTests {
@@ -48,16 +47,12 @@ public class JpaNativeQueryProviderTests {
String sqlQuery = "select * from T_FOOS where value >= :limit";
jpaQueryProvider.setSqlQuery(sqlQuery);
EntityManager entityManager = createMock(EntityManager.class);
Query query = createMock(Query.class);
EntityManager entityManager = mock(EntityManager.class);
Query query = mock(Query.class);
expect(entityManager.createNativeQuery(sqlQuery, Foo.class)).andReturn(query);
replay(entityManager);
when(entityManager.createNativeQuery(sqlQuery, Foo.class)).thenReturn(query);
jpaQueryProvider.setEntityManager(entityManager);
Assert.notNull(jpaQueryProvider.createQuery());
verify(entityManager);
}
}

5
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/database/support/SqlPagingQueryProviderFactoryBeanTests.java
View File

@@ -19,12 +19,14 @@ import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.LinkedHashMap;
import java.util.Map;
import javax.sql.DataSource;
import org.easymock.EasyMock;
import org.junit.Test;
import org.springframework.batch.item.database.Order;
import org.springframework.batch.item.database.PagingQueryProvider;
@@ -49,7 +51,6 @@ public class SqlPagingQueryProviderFactoryBeanTests {
factory.setSortKeys(sortKeys);
DataSource dataSource = DatabaseTypeTestUtils.getMockDataSource(DatabaseType.HSQL.getProductName(), "100.0.0");
factory.setDataSource(dataSource);
EasyMock.replay(dataSource);
}
@Test

18
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/file/mapping/DefaultLineMapperTests.java
View File

@@ -1,9 +1,7 @@
package org.springframework.batch.item.file.mapping;
import static org.easymock.EasyMock.createStrictMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.verify;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.junit.Assert.assertSame;
import org.junit.Test;
@@ -38,21 +36,17 @@ public class DefaultLineMapperTests {
final FieldSet fs = new DefaultFieldSet(new String[]{"token1", "token2"});
final String item = "ITEM";
LineTokenizer tokenizer = createStrictMock(LineTokenizer.class);
expect(tokenizer.tokenize(line)).andReturn(fs);
replay(tokenizer);
LineTokenizer tokenizer = mock(LineTokenizer.class);
when(tokenizer.tokenize(line)).thenReturn(fs);
@SuppressWarnings("unchecked")
FieldSetMapper<String> fsMapper = createStrictMock(FieldSetMapper.class);
expect(fsMapper.mapFieldSet(fs)).andReturn(item);
replay(fsMapper);
FieldSetMapper<String> fsMapper = mock(FieldSetMapper.class);
when(fsMapper.mapFieldSet(fs)).thenReturn(item);
tested.setLineTokenizer(tokenizer);
tested.setFieldSetMapper(fsMapper);
assertSame(item, tested.mapLine(line, 1));
verify(tokenizer);
verify(fsMapper);
}

36
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/jms/JmsItemReaderTests.java
View File

@@ -16,6 +16,9 @@
package org.springframework.batch.item.jms;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
@@ -24,7 +27,6 @@ import java.util.Date;
import javax.jms.Message;
import org.easymock.EasyMock;
import org.junit.Test;
import org.springframework.jms.core.JmsOperations;
import org.springframework.jms.core.JmsTemplate;
@@ -35,48 +37,41 @@ public class JmsItemReaderTests {
@Test
public void testNoItemTypeSunnyDay() {
JmsOperations jmsTemplate = EasyMock.createMock(JmsOperations.class);
EasyMock.expect(jmsTemplate.receiveAndConvert()).andReturn("foo");
EasyMock.replay(jmsTemplate);
JmsOperations jmsTemplate = mock(JmsOperations.class);
when(jmsTemplate.receiveAndConvert()).thenReturn("foo");
itemReader.setJmsTemplate(jmsTemplate);
assertEquals("foo", itemReader.read());
EasyMock.verify(jmsTemplate);
}
@Test
public void testSetItemTypeSunnyDay() {
JmsOperations jmsTemplate = EasyMock.createMock(JmsOperations.class);
EasyMock.expect(jmsTemplate.receiveAndConvert()).andReturn("foo");
EasyMock.replay(jmsTemplate);
JmsOperations jmsTemplate = mock(JmsOperations.class);
when(jmsTemplate.receiveAndConvert()).thenReturn("foo");
itemReader.setJmsTemplate(jmsTemplate);
itemReader.setItemType(String.class);
assertEquals("foo", itemReader.read());
EasyMock.verify(jmsTemplate);
}
@Test
public void testSetItemSubclassTypeSunnyDay() {
JmsOperations jmsTemplate = EasyMock.createMock(JmsOperations.class);
JmsOperations jmsTemplate = mock(JmsOperations.class);
Date date = new java.sql.Date(0L);
EasyMock.expect(jmsTemplate.receiveAndConvert()).andReturn(date);
EasyMock.replay(jmsTemplate);
when(jmsTemplate.receiveAndConvert()).thenReturn(date);
JmsItemReader<Date> itemReader = new JmsItemReader<Date>();
itemReader.setJmsTemplate(jmsTemplate);
itemReader.setItemType(Date.class);
assertEquals(date, itemReader.read());
EasyMock.verify(jmsTemplate);
}
@Test
public void testSetItemTypeMismatch() {
JmsOperations jmsTemplate = EasyMock.createMock(JmsOperations.class);
EasyMock.expect(jmsTemplate.receiveAndConvert()).andReturn("foo");
EasyMock.replay(jmsTemplate);
JmsOperations jmsTemplate = mock(JmsOperations.class);
when(jmsTemplate.receiveAndConvert()).thenReturn("foo");
JmsItemReader<Date> itemReader = new JmsItemReader<Date>();
itemReader.setJmsTemplate(jmsTemplate);
@@ -89,21 +84,18 @@ public class JmsItemReaderTests {
// expected
assertTrue(e.getMessage().indexOf("wrong type") >= 0);
}
EasyMock.verify(jmsTemplate);
}
@Test
public void testNextMessageSunnyDay() {
JmsOperations jmsTemplate = EasyMock.createMock(JmsOperations.class);
Message message = EasyMock.createMock(Message.class);
EasyMock.expect(jmsTemplate.receive()).andReturn(message);
EasyMock.replay(jmsTemplate, message);
JmsOperations jmsTemplate = mock(JmsOperations.class);
Message message = mock(Message.class);
when(jmsTemplate.receive()).thenReturn(message);
JmsItemReader<Message> itemReader = new JmsItemReader<Message>();
itemReader.setJmsTemplate(jmsTemplate);
itemReader.setItemType(Message.class);
assertEquals(message, itemReader.read());
EasyMock.verify(jmsTemplate);
}
@Test(expected=IllegalArgumentException.class)

9
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/jms/JmsItemWriterTests.java
View File

@@ -16,9 +16,10 @@
package org.springframework.batch.item.jms;
import static org.mockito.Mockito.mock;
import java.util.Arrays;
import org.easymock.EasyMock;
import org.junit.Test;
import org.springframework.jms.core.JmsOperations;
import org.springframework.jms.core.JmsTemplate;
@@ -29,16 +30,12 @@ public class JmsItemWriterTests {
@Test
public void testNoItemTypeSunnyDay() throws Exception {
JmsOperations jmsTemplate = EasyMock.createMock(JmsOperations.class);
JmsOperations jmsTemplate = mock(JmsOperations.class);
jmsTemplate.convertAndSend("foo");
EasyMock.expectLastCall();
jmsTemplate.convertAndSend("bar");
EasyMock.expectLastCall();
EasyMock.replay(jmsTemplate);
itemWriter.setJmsTemplate(jmsTemplate);
itemWriter.write(Arrays.asList("foo", "bar"));
EasyMock.verify(jmsTemplate);
}
@Test(expected=IllegalArgumentException.class)

10
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/jms/JmsMethodArgumentsKeyGeneratorTests.java
View File

@@ -16,15 +16,17 @@
package org.springframework.batch.item.jms;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import javax.jms.Message;
import org.easymock.EasyMock;
import org.junit.Test;
/**
* @author Dave Syer
* @author Will Schipp
*
*/
public class JmsMethodArgumentsKeyGeneratorTests {
@@ -33,15 +35,13 @@ public class JmsMethodArgumentsKeyGeneratorTests {
@Test
public void testGetKeyFromMessage() throws Exception {
Message message = EasyMock.createMock(Message.class);
EasyMock.expect(message.getJMSMessageID()).andReturn("foo");
EasyMock.replay(message);
Message message = mock(Message.class);
when(message.getJMSMessageID()).thenReturn("foo");
JmsItemReader<Message> itemReader = new JmsItemReader<Message>();
itemReader.setItemType(Message.class);
assertEquals("foo", methodArgumentsKeyGenerator.getKey(new Object[]{message}));
EasyMock.verify(message);
}
@Test

8
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/jms/JmsMethodInvocationRecovererTests.java
View File

@@ -15,12 +15,14 @@
*/
package org.springframework.batch.item.jms;
import org.easymock.EasyMock;
import static org.mockito.Mockito.mock;
import org.junit.Test;
import org.springframework.jms.core.JmsOperations;
/**
* @author Dave Syer
* @author Will Schipp
*
*/
public class JmsMethodInvocationRecovererTests {
@@ -29,14 +31,12 @@ public class JmsMethodInvocationRecovererTests {
@Test
public void testRecoverWithNoDestination() throws Exception {
JmsOperations jmsTemplate = EasyMock.createMock(JmsOperations.class);
JmsOperations jmsTemplate = mock(JmsOperations.class);
jmsTemplate.convertAndSend("foo");
EasyMock.replay(jmsTemplate);
itemReader.setJmsTemplate(jmsTemplate);
itemReader.recover(new Object[] { "foo" }, null);
EasyMock.verify(jmsTemplate);
}
}

10
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/jms/JmsNewMethodArgumentsIdentifierTests.java
View File

@@ -16,15 +16,17 @@
package org.springframework.batch.item.jms;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import javax.jms.Message;
import org.easymock.EasyMock;
import org.junit.Test;
/**
* @author Dave Syer
* @author Will Schipp
*
*/
public class JmsNewMethodArgumentsIdentifierTests {
@@ -33,12 +35,10 @@ public class JmsNewMethodArgumentsIdentifierTests {
@Test
public void testIsNewForMessage() throws Exception {
Message message = EasyMock.createMock(Message.class);
EasyMock.expect(message.getJMSRedelivered()).andReturn(true);
EasyMock.replay(message);
Message message = mock(Message.class);
when(message.getJMSRedelivered()).thenReturn(true);
assertEquals(false, newMethodArgumentsIdentifier.isNew(new Object[]{message}));
EasyMock.verify(message);
}
@Test

27
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/mail/SimpleMailMessageItemWriterTests.java
View File

@@ -16,6 +16,9 @@
package org.springframework.batch.item.mail;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.mockito.AdditionalMatchers.aryEq;
import java.util.Arrays;
import java.util.Collections;
@@ -23,7 +26,6 @@ import java.util.concurrent.atomic.AtomicReference;
import javax.mail.MessagingException;
import org.easymock.EasyMock;
import org.junit.Before;
import org.junit.Test;
import org.springframework.mail.MailException;
@@ -34,6 +36,7 @@ import org.springframework.mail.SimpleMailMessage;
/**
* @author Dave Syer
* @author Will Schipp
*
* @since 2.1
*
@@ -42,7 +45,7 @@ public class SimpleMailMessageItemWriterTests {
private SimpleMailMessageItemWriter writer = new SimpleMailMessageItemWriter();
private MailSender mailSender = EasyMock.createMock(MailSender.class);
private MailSender mailSender = mock(MailSender.class);
@Before
public void setUp() {
@@ -56,13 +59,10 @@ public class SimpleMailMessageItemWriterTests {
SimpleMailMessage bar = new SimpleMailMessage();
SimpleMailMessage[] items = new SimpleMailMessage[] { foo, bar };
mailSender.send(EasyMock.aryEq(items));
EasyMock.expectLastCall();
EasyMock.replay(mailSender);
mailSender.send(aryEq(items));
writer.write(Arrays.asList(items));
EasyMock.verify(mailSender);
}
@@ -73,15 +73,11 @@ public class SimpleMailMessageItemWriterTests {
SimpleMailMessage bar = new SimpleMailMessage();
SimpleMailMessage[] items = new SimpleMailMessage[] { foo, bar };
mailSender.send(EasyMock.aryEq(items));
EasyMock.expectLastCall().andThrow(
new MailSendException(Collections.singletonMap((Object)foo, (Exception)new MessagingException("FOO"))));
EasyMock.replay(mailSender);
mailSender.send(aryEq(items));
when(mailSender).thenThrow(new MailSendException(Collections.singletonMap((Object)foo, (Exception)new MessagingException("FOO"))));
writer.write(Arrays.asList(items));
EasyMock.verify(mailSender);
}
@Test
@@ -99,16 +95,13 @@ public class SimpleMailMessageItemWriterTests {
SimpleMailMessage bar = new SimpleMailMessage();
SimpleMailMessage[] items = new SimpleMailMessage[] { foo, bar };
mailSender.send(EasyMock.aryEq(items));
EasyMock.expectLastCall().andThrow(
new MailSendException(Collections.singletonMap((Object)foo, (Exception)new MessagingException("FOO"))));
EasyMock.replay(mailSender);
mailSender.send(aryEq(items));
when(mailSender).thenThrow(new MailSendException(Collections.singletonMap((Object)foo, (Exception)new MessagingException("FOO"))));
writer.write(Arrays.asList(items));
assertEquals("FOO", content.get());
EasyMock.verify(mailSender);
}

26
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/mail/javamail/MimeMessageItemWriterTests.java
View File

@@ -16,6 +16,9 @@
package org.springframework.batch.item.mail.javamail;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.mockito.AdditionalMatchers.aryEq;
import java.util.Arrays;
import java.util.Collections;
@@ -26,7 +29,6 @@ import javax.mail.MessagingException;
import javax.mail.Session;
import javax.mail.internet.MimeMessage;
import org.easymock.EasyMock;
import org.junit.Before;
import org.junit.Test;
import org.springframework.batch.item.mail.MailErrorHandler;
@@ -37,6 +39,7 @@ import org.springframework.mail.javamail.JavaMailSender;
/**
* @author Dave Syer
* @author Will Schipp
*
* @since 2.1
*
@@ -45,7 +48,7 @@ public class MimeMessageItemWriterTests {
private MimeMessageItemWriter writer = new MimeMessageItemWriter();
private JavaMailSender mailSender = EasyMock.createMock(JavaMailSender.class);
private JavaMailSender mailSender = mock(JavaMailSender.class);
private Session session = Session.getDefaultInstance(new Properties());
@@ -61,13 +64,10 @@ public class MimeMessageItemWriterTests {
MimeMessage bar = new MimeMessage(session);
MimeMessage[] items = new MimeMessage[] { foo, bar };
mailSender.send(EasyMock.aryEq(items));
EasyMock.expectLastCall();
EasyMock.replay(mailSender);
mailSender.send(aryEq(items));
writer.write(Arrays.asList(items));
EasyMock.verify(mailSender);
}
@@ -78,14 +78,11 @@ public class MimeMessageItemWriterTests {
MimeMessage bar = new MimeMessage(session);
MimeMessage[] items = new MimeMessage[] { foo, bar };
mailSender.send(EasyMock.aryEq(items));
EasyMock.expectLastCall().andThrow(
new MailSendException(Collections.singletonMap((Object)foo, (Exception)new MessagingException("FOO"))));
EasyMock.replay(mailSender);
mailSender.send(aryEq(items));
when(mailSender).thenThrow(new MailSendException(Collections.singletonMap((Object)foo, (Exception)new MessagingException("FOO"))));
writer.write(Arrays.asList(items));
EasyMock.verify(mailSender);
}
@@ -104,16 +101,13 @@ public class MimeMessageItemWriterTests {
MimeMessage bar = new MimeMessage(session);
MimeMessage[] items = new MimeMessage[] { foo, bar };
mailSender.send(EasyMock.aryEq(items));
EasyMock.expectLastCall().andThrow(
new MailSendException(Collections.singletonMap((Object)foo, (Exception) new MessagingException("FOO"))));
EasyMock.replay(mailSender);
mailSender.send(aryEq(items));
when(mailSender).thenThrow(new MailSendException(Collections.singletonMap((Object)foo, (Exception)new MessagingException("FOO"))));
writer.write(Arrays.asList(items));
assertEquals("FOO", content.get());
EasyMock.verify(mailSender);
}

26
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/support/CompositeItemProcessorTests.java
View File

@@ -1,9 +1,7 @@
package org.springframework.batch.item.support;
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.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.fail;
@@ -19,6 +17,7 @@ import org.springframework.batch.item.support.CompositeItemProcessor;
* Tests for {@link CompositeItemProcessor}.
*
* @author Robert Kasanicky
* @author Will Schipp
*/
public class CompositeItemProcessorTests {
@@ -30,8 +29,8 @@ public class CompositeItemProcessorTests {
@SuppressWarnings("unchecked")
@Before
public void setUp() throws Exception {
processor1 = createMock(ItemProcessor.class);
processor2 = createMock(ItemProcessor.class);
processor1 = mock(ItemProcessor.class);
processor2 = mock(ItemProcessor.class);
composite.setDelegates(new ArrayList<ItemProcessor<Object,Object>>() {{
add(processor1); add(processor2);
@@ -50,17 +49,12 @@ public class CompositeItemProcessorTests {
Object itemAfterFirstTransfromation = new Object();
Object itemAfterSecondTransformation = new Object();
expect(processor1.process(item)).andReturn(itemAfterFirstTransfromation);
expect(processor2.process(itemAfterFirstTransfromation)).andReturn(itemAfterSecondTransformation);
replay(processor1);
replay(processor2);
when(processor1.process(item)).thenReturn(itemAfterFirstTransfromation);
when(processor2.process(itemAfterFirstTransfromation)).thenReturn(itemAfterSecondTransformation);
assertSame(itemAfterSecondTransformation, composite.process(item));
verify(processor1);
verify(processor2);
}
/**
@@ -96,9 +90,7 @@ public class CompositeItemProcessorTests {
public void testFilteredItemInFirstProcessor() throws Exception{
Object item = new Object();
expect(processor1.process(item)).andReturn(null);
replay(processor1, processor2);
when(processor1.process(item)).thenReturn(null);
Assert.assertEquals(null,composite.process(item));
verify(processor1,processor2);
}
}

22
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/support/CompositeItemWriterTests.java
View File

@@ -1,9 +1,7 @@
package org.springframework.batch.item.support;
import static org.easymock.EasyMock.createStrictMock;
import static org.easymock.EasyMock.expectLastCall;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.verify;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.Collections;
@@ -18,6 +16,7 @@ import org.springframework.batch.item.ItemWriter;
* Tests for {@link CompositeItemWriter}
*
* @author Robert Kasanicky
* @author Will Schipp
*/
public class CompositeItemWriterTests {
@@ -37,11 +36,9 @@ public class CompositeItemWriterTests {
for (int i = 0; i < NUMBER_OF_WRITERS; i++) {
@SuppressWarnings("unchecked")
ItemWriter<? super Object> writer = createStrictMock(ItemWriter.class);
ItemWriter<? super Object> writer = mock(ItemWriter.class);
writer.write(data);
expectLastCall().once();
replay(writer);
writers.add(writer);
}
@@ -49,9 +46,7 @@ public class CompositeItemWriterTests {
itemWriter.setDelegates(writers);
itemWriter.write(data);
for (ItemWriter<? super Object> writer : writers) {
verify(writer);
}
}
@Test
@@ -66,16 +61,13 @@ public class CompositeItemWriterTests {
private void doTestItemStream(boolean expectOpen) throws Exception {
@SuppressWarnings("unchecked")
ItemStreamWriter<? super Object> writer = createStrictMock(ItemStreamWriter.class);
ItemStreamWriter<? super Object> writer = mock(ItemStreamWriter.class);
List<Object> data = Collections.singletonList(new Object());
ExecutionContext executionContext = new ExecutionContext();
if (expectOpen) {
writer.open(executionContext);
expectLastCall().once();
}
writer.write(data);
expectLastCall().once();
replay(writer);
List<ItemWriter<? super Object>> writers = new ArrayList<ItemWriter<? super Object>>();
writers.add(writer);
@@ -85,8 +77,6 @@ public class CompositeItemWriterTests {
itemWriter.open(executionContext);
}
itemWriter.write(data);
verify(writer);
}
}

15
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/validator/ValidatingItemProcessorTests.java
View File

@@ -1,9 +1,7 @@
package org.springframework.batch.item.validator;
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.expectLastCall;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.verify;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
@@ -15,7 +13,7 @@ import org.junit.Test;
public class ValidatingItemProcessorTests {
@SuppressWarnings("unchecked")
private Validator<String> validator = createMock(Validator.class);
private Validator<String> validator = mock(Validator.class);
private static final String ITEM = "item";
@@ -25,12 +23,8 @@ public class ValidatingItemProcessorTests {
ValidatingItemProcessor<String> tested = new ValidatingItemProcessor<String>(validator);
validator.validate(ITEM);
expectLastCall();
replay(validator);
assertSame(ITEM, tested.process(ITEM));
verify(validator);
}
@Test(expected = ValidationException.class)
@@ -52,8 +46,7 @@ public class ValidatingItemProcessorTests {
private String processFailedValidation(ValidatingItemProcessor<String> tested) {
validator.validate(ITEM);
expectLastCall().andThrow(new ValidationException("invalid item"));
replay(validator);
when(validator).thenThrow(new ValidationException("invalid item"));
return tested.process(ITEM);
}

12
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/xml/StaxEventItemWriterTests.java
View File

@@ -1,8 +1,7 @@
package org.springframework.batch.item.xml;
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.replay;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
@@ -329,10 +328,9 @@ public class StaxEventItemWriterTests {
@Test
public void testNonExistantResource() throws Exception {
Resource doesntExist = createMock(Resource.class);
expect(doesntExist.getFile()).andReturn(File.createTempFile("arbitrary", null));
expect(doesntExist.exists()).andReturn(false);
replay(doesntExist);
Resource doesntExist = mock(Resource.class);
when(doesntExist.getFile()).thenReturn(File.createTempFile("arbitrary", null));
when(doesntExist.exists()).thenReturn(false);
writer.setResource(doesntExist);

51
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/xml/stax/AbstractEventReaderWrapperTests.java
View File

@@ -15,11 +15,8 @@
*/
package org.springframework.batch.item.xml.stax;
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.expectLastCall;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.verify;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLStreamException;
@@ -29,7 +26,7 @@ import junit.framework.TestCase;
/**
* @author Lucas Ward
*
* @author Will Schipp
*/
public class AbstractEventReaderWrapperTests extends TestCase {
@@ -40,87 +37,67 @@ public class AbstractEventReaderWrapperTests extends TestCase {
protected void setUp() throws Exception {
super.setUp();
xmlEventReader = createMock(XMLEventReader.class);
xmlEventReader = mock(XMLEventReader.class);
eventReaderWrapper = new StubEventReader(xmlEventReader);
}
public void testClose() throws XMLStreamException {
xmlEventReader.close();
expectLastCall().once();
replay(xmlEventReader);
eventReaderWrapper.close();
verify(xmlEventReader);
}
public void testGetElementText() throws XMLStreamException {
String text = "text";
expect(xmlEventReader.getElementText()).andReturn(text);
replay(xmlEventReader);
when(xmlEventReader.getElementText()).thenReturn(text);
assertEquals(eventReaderWrapper.getElementText(), text);
verify(xmlEventReader);
}
public void testGetProperty() throws IllegalArgumentException {
String text = "text";
expect(xmlEventReader.getProperty("name")).andReturn(text);
replay(xmlEventReader);
when(xmlEventReader.getProperty("name")).thenReturn(text);
assertEquals(eventReaderWrapper.getProperty("name"), text);
verify(xmlEventReader);
}
public void testHasNext() {
expect(xmlEventReader.hasNext()).andReturn(true);
replay(xmlEventReader);
when(xmlEventReader.hasNext()).thenReturn(true);
assertTrue(eventReaderWrapper.hasNext());
verify(xmlEventReader);
}
public void testNext() {
String text = "text";
expect(xmlEventReader.next()).andReturn(text);
replay(xmlEventReader);
when(xmlEventReader.next()).thenReturn(text);
assertEquals(eventReaderWrapper.next(), text);
verify(xmlEventReader);
}
public void testNextEvent() throws XMLStreamException {
XMLEvent event = createMock(XMLEvent.class);
expect(xmlEventReader.nextEvent()).andReturn(event);
replay(xmlEventReader);
XMLEvent event = mock(XMLEvent.class);
when(xmlEventReader.nextEvent()).thenReturn(event);
assertEquals(eventReaderWrapper.nextEvent(), event);
verify(xmlEventReader);
}
public void testNextTag() throws XMLStreamException {
XMLEvent event = createMock(XMLEvent.class);
expect(xmlEventReader.nextTag()).andReturn(event);
replay(xmlEventReader);
XMLEvent event = mock(XMLEvent.class);
when(xmlEventReader.nextTag()).thenReturn(event);
assertEquals(eventReaderWrapper.nextTag(), event);
verify(xmlEventReader);
}
public void testPeek() throws XMLStreamException {
XMLEvent event = createMock(XMLEvent.class);
expect(xmlEventReader.peek()).andReturn(event);
replay(xmlEventReader);
XMLEvent event = mock(XMLEvent.class);
when(xmlEventReader.peek()).thenReturn(event);
assertEquals(eventReaderWrapper.peek(), event);
verify(xmlEventReader);
}
public void testRemove() {
xmlEventReader.remove();
expectLastCall().once();
replay(xmlEventReader);
eventReaderWrapper.remove();
verify(xmlEventReader);
}
private static class StubEventReader extends AbstractEventReaderWrapper {

50
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/xml/stax/AbstractEventWriterWrapperTests.java
View File

@@ -15,11 +15,8 @@
*/
package org.springframework.batch.item.xml.stax;
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.expectLastCall;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.verify;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import javax.xml.namespace.NamespaceContext;
import javax.xml.stream.XMLEventReader;
@@ -29,11 +26,9 @@ import javax.xml.stream.events.XMLEvent;
import junit.framework.TestCase;
import org.easymock.EasyMock;
/**
* @author Lucas Ward
* @author Will Schipp
*
*/
public class AbstractEventWriterWrapperTests extends TestCase {
@@ -46,80 +41,58 @@ public class AbstractEventWriterWrapperTests extends TestCase {
protected void setUp() throws Exception {
super.setUp();
xmlEventWriter = createMock(XMLEventWriter.class);
xmlEventWriter = mock(XMLEventWriter.class);
eventWriterWrapper = new StubEventWriter(xmlEventWriter);
}
public void testAdd() throws XMLStreamException {
XMLEvent event = EasyMock.createMock(XMLEvent.class);
XMLEvent event = mock(XMLEvent.class);
xmlEventWriter.add(event);
expectLastCall();
replay(xmlEventWriter);
eventWriterWrapper.add(event);
verify(xmlEventWriter);
}
public void testAddReader() throws XMLStreamException {
XMLEventReader reader = createMock(XMLEventReader.class);
XMLEventReader reader = mock(XMLEventReader.class);
xmlEventWriter.add(reader);
expectLastCall().once();
replay(xmlEventWriter);
eventWriterWrapper.add(reader);
verify(xmlEventWriter);
}
public void testClose() throws XMLStreamException {
xmlEventWriter.close();
expectLastCall().once();
replay(xmlEventWriter);
eventWriterWrapper.close();
verify(xmlEventWriter);
}
public void testFlush() throws XMLStreamException {
xmlEventWriter.flush();
expectLastCall().once();
replay(xmlEventWriter);
eventWriterWrapper.flush();
verify(xmlEventWriter);
}
public void testGetNamespaceContext() {
NamespaceContext context = EasyMock.createMock(NamespaceContext.class);
expect(xmlEventWriter.getNamespaceContext()).andReturn(context);
replay(xmlEventWriter);
NamespaceContext context = mock(NamespaceContext.class);
when(xmlEventWriter.getNamespaceContext()).thenReturn(context);
assertEquals(eventWriterWrapper.getNamespaceContext(), context);
verify(xmlEventWriter);
}
public void testGetPrefix() throws XMLStreamException {
String uri = "uri";
expect(xmlEventWriter.getPrefix(uri)).andReturn(uri);
replay(xmlEventWriter);
when(xmlEventWriter.getPrefix(uri)).thenReturn(uri);
assertEquals(eventWriterWrapper.getPrefix(uri), uri);
verify(xmlEventWriter);
}
public void testSetDefaultNamespace() throws XMLStreamException {
String uri = "uri";
xmlEventWriter.setDefaultNamespace(uri);
expectLastCall().once();
replay(xmlEventWriter);
eventWriterWrapper.setDefaultNamespace(uri);
verify(xmlEventWriter);
}
public void testSetNamespaceContext() throws XMLStreamException {
NamespaceContext context = EasyMock.createMock(NamespaceContext.class);
NamespaceContext context = mock(NamespaceContext.class);
xmlEventWriter.setNamespaceContext(context);
expectLastCall().once();
replay(xmlEventWriter);
eventWriterWrapper.setNamespaceContext(context);
verify(xmlEventWriter);
}
public void testSetPrefix() throws XMLStreamException {
@@ -127,10 +100,7 @@ public class AbstractEventWriterWrapperTests extends TestCase {
String uri = "uri";
String prefix = "prefix";
xmlEventWriter.setPrefix(prefix, uri);
expectLastCall().once();
replay(xmlEventWriter);
eventWriterWrapper.setPrefix(prefix, uri);
verify(xmlEventWriter);
}
private static class StubEventWriter extends AbstractEventWriterWrapper {

8
spring-batch-infrastructure/src/test/java/org/springframework/batch/item/xml/stax/NoStartEndDocumentWriterTests.java
View File

@@ -6,12 +6,13 @@ import javax.xml.stream.events.XMLEvent;
import junit.framework.TestCase;
import static org.easymock.EasyMock.*;
import static org.mockito.Mockito.mock;
/**
* Tests for {@link NoStartEndDocumentStreamWriter}
*
* @author Robert Kasanicky
* @author Will Schipp
*/
public class NoStartEndDocumentWriterTests extends TestCase {
@@ -24,7 +25,7 @@ public class NoStartEndDocumentWriterTests extends TestCase {
@Override
protected void setUp() throws Exception {
wrappedWriter = createStrictMock(XMLEventWriter.class);
wrappedWriter = mock(XMLEventWriter.class);
writer = new NoStartEndDocumentStreamWriter(wrappedWriter);
}
@@ -37,13 +38,10 @@ public class NoStartEndDocumentWriterTests extends TestCase {
// mock expects only a single event
wrappedWriter.add(event);
expectLastCall().once();
replay(wrappedWriter);
writer.add(eventFactory.createStartDocument());
writer.add(event);
writer.add(eventFactory.createEndDocument());
verify(wrappedWriter);
}
}

25
spring-batch-infrastructure/src/test/java/org/springframework/batch/support/DatabaseTypeTestUtils.java
View File

@@ -15,9 +15,8 @@
*/
package org.springframework.batch.support;
import static org.easymock.EasyMock.createNiceMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.replay;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
@@ -28,6 +27,7 @@ import org.apache.commons.dbcp.BasicDataSource;
/**
* @author Dave Syer
* @author Will Schipp
*
*/
public class DatabaseTypeTestUtils {
@@ -54,22 +54,21 @@ public class DatabaseTypeTestUtils {
}
public static DataSource getMockDataSource(String databaseProductName, String databaseVersion) throws Exception {
DatabaseMetaData dmd = createNiceMock(DatabaseMetaData.class);
DataSource ds = createNiceMock(DataSource.class);
Connection con = createNiceMock(Connection.class);
expect(ds.getConnection()).andReturn(con).anyTimes();
expect(con.getMetaData()).andReturn(dmd).anyTimes();
expect(dmd.getDatabaseProductName()).andReturn(databaseProductName).anyTimes();
DatabaseMetaData dmd = mock(DatabaseMetaData.class);
DataSource ds = mock(DataSource.class);
Connection con = mock(Connection.class);
when(ds.getConnection()).thenReturn(con);
when(con.getMetaData()).thenReturn(dmd);
when(dmd.getDatabaseProductName()).thenReturn(databaseProductName);
if (databaseVersion!=null) {
expect(dmd.getDatabaseProductVersion()).andReturn(databaseVersion).anyTimes();
when(dmd.getDatabaseProductVersion()).thenReturn(databaseVersion);
}
replay(dmd, con);
return ds;
}
public static DataSource getMockDataSource(Exception e) throws Exception {
DataSource ds = createNiceMock(DataSource.class);
expect(ds.getConnection()).andReturn(null).anyTimes();
DataSource ds = mock(DataSource.class);
when(ds.getConnection()).thenReturn(null);
return ds;
}

23
spring-batch-infrastructure/src/test/java/org/springframework/batch/support/DatabaseTypeTests.java
View File

@@ -1,7 +1,5 @@
package org.springframework.batch.support;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.verify;
import static org.junit.Assert.assertEquals;
import static org.springframework.batch.support.DatabaseType.DB2;
import static org.springframework.batch.support.DatabaseType.DB2ZOS;
@@ -22,6 +20,7 @@ import org.springframework.jdbc.support.MetaDataAccessException;
/**
*
* @author Lucas Ward
* @author Will Schipp
*
*/
public class DatabaseTypeTests {
@@ -48,81 +47,61 @@ public class DatabaseTypeTests {
@Test
public void testFromMetaDataForDerby() throws Exception {
DataSource ds = DatabaseTypeTestUtils.getMockDataSource("Apache Derby");
replay(ds);
assertEquals(DERBY, DatabaseType.fromMetaData(ds));
verify(ds);
}
@Test
public void testFromMetaDataForDB2() throws Exception {
DataSource ds = DatabaseTypeTestUtils.getMockDataSource("DB2/Linux");
replay(ds);
assertEquals(DB2, DatabaseType.fromMetaData(ds));
verify(ds);
}
@Test
public void testFromMetaDataForDB2ZOS() throws Exception {
DataSource ds = DatabaseTypeTestUtils.getMockDataSource("DB2", "DSN08015");
replay(ds);
assertEquals(DB2ZOS, DatabaseType.fromMetaData(ds));
verify(ds);
}
@Test
public void testFromMetaDataForHsql() throws Exception {
DataSource ds = DatabaseTypeTestUtils.getMockDataSource("HSQL Database Engine");
replay(ds);
assertEquals(HSQL, DatabaseType.fromMetaData(ds));
verify(ds);
}
@Test
public void testFromMetaDataForSqlServer() throws Exception {
DataSource ds = DatabaseTypeTestUtils.getMockDataSource("Microsoft SQL Server");
replay(ds);
assertEquals(SQLSERVER, DatabaseType.fromMetaData(ds));
verify(ds);
}
@Test
public void testFromMetaDataForMySql() throws Exception {
DataSource ds = DatabaseTypeTestUtils.getMockDataSource("MySQL");
replay(ds);
assertEquals(MYSQL, DatabaseType.fromMetaData(ds));
verify(ds);
}
@Test
public void testFromMetaDataForOracle() throws Exception {
DataSource ds = DatabaseTypeTestUtils.getMockDataSource("Oracle");
replay(ds);
assertEquals(ORACLE, DatabaseType.fromMetaData(ds));
verify(ds);
}
@Test
public void testFromMetaDataForPostgres() throws Exception {
DataSource ds = DatabaseTypeTestUtils.getMockDataSource("PostgreSQL");
replay(ds);
assertEquals(POSTGRES, DatabaseType.fromMetaData(ds));
verify(ds);
}
@Test
public void testFromMetaDataForSybase() throws Exception {
DataSource ds = DatabaseTypeTestUtils.getMockDataSource("Adaptive Server Enterprise");
replay(ds);
assertEquals(SYBASE, DatabaseType.fromMetaData(ds));
verify(ds);
}
@Test(expected=MetaDataAccessException.class)
public void testBadMetaData() throws Exception {
DataSource ds = DatabaseTypeTestUtils.getMockDataSource(new MetaDataAccessException("Bad!"));
replay(ds);
assertEquals(SYBASE, DatabaseType.fromMetaData(ds));
verify(ds);
}
}

59
spring-batch-infrastructure/src/test/java/org/springframework/batch/support/transaction/TransactionAwareBufferedWriterTests.java
View File

@@ -15,30 +15,30 @@
*/
package org.springframework.batch.support.transaction;
import static org.easymock.EasyMock.anyObject;
import static org.easymock.EasyMock.capture;
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.fail;
import static org.mockito.Matchers.anyObject;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import org.easymock.Capture;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallback;
import org.springframework.transaction.support.TransactionTemplate;
//import org.easymock.Capture;
/**
* @author Dave Syer
* @author Michael Minella
* @author Will Schipp
*
*/
public class TransactionAwareBufferedWriterTests {
@@ -49,7 +49,7 @@ public class TransactionAwareBufferedWriterTests {
@Before
public void init() {
fileChannel = createMock(FileChannel.class);
fileChannel = mock(FileChannel.class);
writer = new TransactionAwareBufferedWriter(fileChannel, new Runnable() {
@Override
@@ -75,10 +75,11 @@ public class TransactionAwareBufferedWriterTests {
*/
@Test
public void testWriteOutsideTransaction() throws Exception {
Capture<ByteBuffer> bb = new Capture<ByteBuffer>();
expect(fileChannel.write(capture(bb))).andReturn(3);
// Capture<ByteBuffer> bb = new Capture<ByteBuffer>();
ArgumentCaptor<ByteBuffer> bb = ArgumentCaptor.forClass(ByteBuffer.class);
// when(fileChannel.write(capture(bb))).thenReturn(3);
when(fileChannel.write(bb.capture())).thenReturn(3);
fileChannel.force(false);
replay(fileChannel);
writer.write("foo");
writer.flush();
@@ -86,35 +87,31 @@ public class TransactionAwareBufferedWriterTests {
String s = getStringFromByteBuffer(bb.getValue());
verify(fileChannel);
assertEquals("foo", s);
}
@Test
public void testBufferSizeOutsideTransaction() throws Exception {
Capture<ByteBuffer> bb = new Capture<ByteBuffer>();
expect(fileChannel.write(capture(bb))).andReturn(3);
replay(fileChannel);
// Capture<ByteBuffer> bb = new Capture<ByteBuffer>();
ArgumentCaptor<ByteBuffer> bb = ArgumentCaptor.forClass(ByteBuffer.class);
when(fileChannel.write(bb.capture())).thenReturn(3);
writer.write("foo");
verify(fileChannel);
assertEquals(0, writer.getBufferSize());
}
@Ignore //TODO - need to fix capture test
@Test
public void testCloseOutsideTransaction() throws Exception {
Capture<ByteBuffer> writeBuffer = new Capture<ByteBuffer>();
Capture<ByteBuffer> commitBuffer = new Capture<ByteBuffer>();
expect(fileChannel.write(capture(writeBuffer))).andReturn(3);
expect(fileChannel.write(capture(commitBuffer))).andReturn(1);
replay(fileChannel);
ArgumentCaptor<ByteBuffer> writeBuffer = ArgumentCaptor.forClass(ByteBuffer.class);
ArgumentCaptor<ByteBuffer> commitBuffer = ArgumentCaptor.forClass(ByteBuffer.class);
when(fileChannel.write(writeBuffer.capture())).thenReturn(4);
when(fileChannel.write(commitBuffer.capture())).thenReturn(1);
writer.write("foo");
writer.close();
verify(fileChannel);
assertEquals("foo", getStringFromByteBuffer(writeBuffer.getValue()));
assertEquals("c", getStringFromByteBuffer(commitBuffer.getValue()));
}
@@ -122,8 +119,7 @@ public class TransactionAwareBufferedWriterTests {
@Test
@SuppressWarnings({"unchecked", "rawtypes"})
public void testFlushInTransaction() throws Exception {
expect(fileChannel.write((ByteBuffer)anyObject())).andReturn(3);
replay(fileChannel);
when(fileChannel.write((ByteBuffer)anyObject())).thenReturn(3);
new TransactionTemplate(transactionManager).execute(new TransactionCallback() {
@Override
@@ -140,15 +136,13 @@ public class TransactionAwareBufferedWriterTests {
}
});
verify(fileChannel);
}
@Test
@SuppressWarnings({"unchecked", "rawtypes"})
public void testWriteWithCommit() throws Exception {
Capture<ByteBuffer> bb = new Capture<ByteBuffer>();
expect(fileChannel.write(capture(bb))).andReturn(3);
replay(fileChannel);
ArgumentCaptor<ByteBuffer> bb = ArgumentCaptor.forClass(ByteBuffer.class);
when(fileChannel.write(bb.capture())).thenReturn(3);
new TransactionTemplate(transactionManager).execute(new TransactionCallback() {
@Override
@@ -164,16 +158,14 @@ public class TransactionAwareBufferedWriterTests {
}
});
verify(fileChannel);
assertEquals(0, writer.getBufferSize());
}
@Test
@SuppressWarnings({"unchecked", "rawtypes"})
public void testBufferSizeInTransaction() throws Exception {
Capture<ByteBuffer> bb = new Capture<ByteBuffer>();
expect(fileChannel.write(capture(bb))).andReturn(3);
replay(fileChannel);
ArgumentCaptor<ByteBuffer> bb = ArgumentCaptor.forClass(ByteBuffer.class);
when(fileChannel.write(bb.capture())).thenReturn(3);
new TransactionTemplate(transactionManager).execute(new TransactionCallback() {
@Override
@@ -189,7 +181,6 @@ public class TransactionAwareBufferedWriterTests {
}
});
verify(fileChannel);
assertEquals(0, writer.getBufferSize());
}