JMock -> Mockito

Author: emacarron

pom.xml

@@ -169,24 +169,12 @@
       <version>10.3.2.1</version>
       <scope>test</scope>
     </dependency>
-    <dependency>
-      <groupId>org.jmock</groupId>
-      <artifactId>jmock-junit4</artifactId>
-      <version>2.5.1</version>
+	<dependency>
+	  <groupId>org.mockito</groupId>
+	  <artifactId>mockito-core</artifactId>
+	  <version>1.9.0</version>
       <scope>test</scope>
-    </dependency>
-    <dependency>
-      <groupId>org.jmock</groupId>
-      <artifactId>jmock-legacy</artifactId>
-      <version>2.5.1</version>
-      <scope>test</scope>
-      <exclusions>
-        <exclusion>
-          <groupId>cglib</groupId>
-          <artifactId>cglib-nodep</artifactId>
-        </exclusion>
-      </exclusions>
-    </dependency>
+	</dependency>    
     <dependency>
       <groupId>commons-dbcp</groupId>
       <artifactId>commons-dbcp</artifactId>

src/test/java/org/apache/ibatis/executor/resultset/FastResultSetHandlerTest.java

@@ -15,7 +15,8 @@
  */
 package org.apache.ibatis.executor.resultset;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.when;
 
 import java.sql.Connection;
 import java.sql.DatabaseMetaData;
@@ -39,13 +40,24 @@
 import org.apache.ibatis.session.ResultHandler;
 import org.apache.ibatis.session.RowBounds;
 import org.apache.ibatis.type.TypeHandlerRegistry;
-import org.jmock.Expectations;
-import org.jmock.Mockery;
-import org.jmock.integration.junit4.JUnit4Mockery;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
 
+@RunWith(MockitoJUnitRunner.class)
 public class FastResultSetHandlerTest {
-  private Mockery context = new JUnit4Mockery();
+
+  @Mock
+  private Statement stmt;
+  @Mock
+  private ResultSet rs;
+  @Mock
+  private ResultSetMetaData rsmd;
+  @Mock
+  private Connection conn;
+  @Mock
+  private DatabaseMetaData dbmd;
 
   /**
    * Contrary to the spec, some drivers require case-sensitive column names when getting result.
@@ -54,17 +66,19 @@ public class FastResultSetHandlerTest {
    */
   @Test
   public void shouldRetainColumnNameCase() throws Exception {
+
     final Configuration config = new Configuration();
     final TypeHandlerRegistry registry = config.getTypeHandlerRegistry();
-    final MappedStatement ms = new MappedStatement.Builder(config, "testSelect", new StaticSqlSource(config, "some select statement"), SqlCommandType.SELECT).resultMaps(new ArrayList<ResultMap>() {
-      {
-        add(new ResultMap.Builder(config, "testMap", HashMap.class, new ArrayList() {
+    final MappedStatement ms = new MappedStatement.Builder(config, "testSelect", new StaticSqlSource(config, "some select statement"), SqlCommandType.SELECT).resultMaps(
+        new ArrayList<ResultMap>() {
           {
-            add(new ResultMapping.Builder(config, "cOlUmN1", "CoLuMn1", registry.getTypeHandler(Integer.class)).build());
+            add(new ResultMap.Builder(config, "testMap", HashMap.class, new ArrayList() {
+              {
+                add(new ResultMapping.Builder(config, "cOlUmN1", "CoLuMn1", registry.getTypeHandler(Integer.class)).build());
+              }
+            }).build());
           }
-        }).build());
-      }
-    }).build();
+        }).build();
 
     final Executor executor = null;
     final ParameterHandler parameterHandler = null;
@@ -73,49 +87,19 @@ public void shouldRetainColumnNameCase() throws Exception {
     final RowBounds rowBounds = new RowBounds(0, 100);
     final FastResultSetHandler fastResultSetHandler = new FastResultSetHandler(executor, ms, parameterHandler, resultHandler, boundSql, rowBounds);
 
-    final Statement stmt = context.mock(Statement.class);
-    final ResultSet rs = context.mock(ResultSet.class);
-    final ResultSetMetaData rsmd = context.mock(ResultSetMetaData.class);
-    final Connection conn = context.mock(Connection.class);
-    final DatabaseMetaData dbmd = context.mock(DatabaseMetaData.class);
-
-    context.checking(new Expectations() {
-      {
-        allowing(stmt).getResultSet();
-        will(returnValue(rs));
-
-        allowing(rs).getMetaData();
-        will(returnValue(rsmd));
-        allowing(rs).getType();
-        will(returnValue(ResultSet.TYPE_FORWARD_ONLY));
-        allowing(rs).close();
-        oneOf(rs).next();
-        will(returnValue(true));
-        oneOf(rs).next();
-        will(returnValue(false)); // just one row.
-        allowing(rs).getInt("CoLuMn1");
-        will(returnValue(100));
-        allowing(rs).wasNull();
-        will(returnValue(false));
-
-        allowing(rsmd).getColumnCount();
-        will(returnValue(1));
-        allowing(rsmd).getColumnLabel(1);
-        will(returnValue("CoLuMn1"));
-        allowing(rsmd).getColumnType(1);
-        will(returnValue(Types.INTEGER));
-        allowing(rsmd).getColumnClassName(1);
-        will(returnValue(Integer.class.getCanonicalName()));
-        allowing(stmt).getConnection();
-        will(returnValue(conn));
-
-        allowing(conn).getMetaData();
-        will(returnValue(dbmd));
-
-        allowing(dbmd).supportsMultipleResultSets();
-        will(returnValue(false)); // for simplicity.
-      }
-    });
+    when(stmt.getResultSet()).thenReturn(rs);
+    when(rs.getMetaData()).thenReturn(rsmd);
+    when(rs.getType()).thenReturn(ResultSet.TYPE_FORWARD_ONLY);
+    when(rs.next()).thenReturn(true).thenReturn(false);
+    when(rs.getInt("CoLuMn1")).thenReturn(100);
+    when(rs.wasNull()).thenReturn(false);
+    when(rsmd.getColumnCount()).thenReturn(1);
+    when(rsmd.getColumnLabel(1)).thenReturn("CoLuMn1");
+    when(rsmd.getColumnType(1)).thenReturn(Types.INTEGER);
+    when(rsmd.getColumnClassName(1)).thenReturn(Integer.class.getCanonicalName());
+    when(stmt.getConnection()).thenReturn(conn);
+    when(conn.getMetaData()).thenReturn(dbmd);
+    when(dbmd.supportsMultipleResultSets()).thenReturn(false); // for simplicity.
 
     final List<Object> results = fastResultSetHandler.handleResultSets(stmt);
     assertEquals(1, results.size());

src/test/java/org/apache/ibatis/transaction/managed/ManagedTransactionFactoryTest.java

@@ -15,65 +15,47 @@
  */
 package org.apache.ibatis.transaction.managed;
 
-import org.apache.ibatis.BaseDataTest;
-import org.apache.ibatis.transaction.Transaction;
-import org.apache.ibatis.transaction.TransactionFactory;
-import org.jmock.Expectations;
-import org.jmock.Mockery;
-import org.jmock.lib.legacy.ClassImposteriser;
 import static org.junit.Assert.assertEquals;
-import org.junit.Test;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
 
 import java.sql.Connection;
 import java.util.Properties;
 
-public class ManagedTransactionFactoryTest extends BaseDataTest {
+import org.apache.ibatis.BaseDataTest;
+import org.apache.ibatis.transaction.Transaction;
+import org.apache.ibatis.transaction.TransactionFactory;
+import org.junit.Test;
+import org.mockito.Mockito;
 
-  protected Mockery mockery = new Mockery() {
-    {
-      setImposteriser(ClassImposteriser.INSTANCE);
-    }
-  };
+public class ManagedTransactionFactoryTest extends BaseDataTest {
 
-  protected final Connection conn = mockery.mock(Connection.class);
+  protected final Connection conn = Mockito.mock(Connection.class);
 
   @Test
   public void shouldEnsureThatCallsToManagedTransactionAPIDoNotForwardToManagedConnections() throws Exception {
-    mockery.checking(new Expectations() {
-      {
-        one(conn).close();
-      }
-    });
-
     TransactionFactory tf = new ManagedTransactionFactory();
     tf.setProperties(new Properties());
     Transaction tx = tf.newTransaction(conn);
     assertEquals(conn, tx.getConnection());
     tx.commit();
     tx.rollback();
     tx.close();
-    mockery.assertIsSatisfied();
+    verify(conn).close();
   }
 
-
   @Test
   public void shouldEnsureThatCallsToManagedTransactionAPIDoNotForwardToManagedConnectionsAndDoesNotCloseConnection() throws Exception {
-    mockery.checking(new Expectations() {
-      {
-        never(conn).close();
-      }
-    }); 
-
     TransactionFactory tf = new ManagedTransactionFactory();
     Properties props = new Properties();
-    props.setProperty("closeConnection","false");
+    props.setProperty("closeConnection", "false");
     tf.setProperties(props);
     Transaction tx = tf.newTransaction(conn);
     assertEquals(conn, tx.getConnection());
     tx.commit();
     tx.rollback();
     tx.close();
-    mockery.assertIsSatisfied();
+    verifyNoMoreInteractions(conn);
   }
 
 }

src/test/java/org/apache/ibatis/type/BaseTypeHandlerTest.java

@@ -15,31 +15,31 @@
  */
 package org.apache.ibatis.type;
 
-import org.jmock.Mockery;
-import org.jmock.lib.legacy.ClassImposteriser;
+import java.sql.CallableStatement;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
 
-import java.sql.*;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
 
+@RunWith(MockitoJUnitRunner.class)
 public abstract class BaseTypeHandlerTest {
 
-  protected Mockery mockery = new Mockery() {
-    {
-      setImposteriser(ClassImposteriser.INSTANCE);
-    }
-  };
+  @Mock
+  protected ResultSet rs;
+  @Mock
+  protected PreparedStatement ps;
+  @Mock
+  protected CallableStatement cs;
+  @Mock
+  protected ResultSetMetaData rsmd;
 
-  protected final ResultSet rs = mockery.mock(ResultSet.class);
-  protected final PreparedStatement ps = mockery.mock(PreparedStatement.class);
-  protected final CallableStatement cs = mockery.mock(CallableStatement.class);
-  protected final ResultSetMetaData rsmd = mockery.mock(ResultSetMetaData.class);
+  public abstract void shouldSetParameter() throws Exception;
 
-  public abstract void shouldSetParameter()
-      throws Exception;
+  public abstract void shouldGetResultFromResultSet() throws Exception;
 
-  public abstract void shouldGetResultFromResultSet()
-      throws Exception;
-
-  public abstract void shouldGetResultFromCallableStatement()
-      throws Exception;
+  public abstract void shouldGetResultFromCallableStatement() throws Exception;
 
 }

src/test/java/org/apache/ibatis/type/BigDecimalTypeHandlerTest.java

@@ -15,57 +15,36 @@
  */
 package org.apache.ibatis.type;
 
-import org.jmock.Expectations;
 import static org.junit.Assert.assertEquals;
-import org.junit.Test;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 import java.math.BigDecimal;
 
+import org.junit.Test;
+
 public class BigDecimalTypeHandlerTest extends BaseTypeHandlerTest {
 
-  private static final TypeHandler TYPE_HANDLER = new BigDecimalTypeHandler();
+  private static final TypeHandler<BigDecimal> TYPE_HANDLER = new BigDecimalTypeHandler();
 
   @Test
-  public void shouldSetParameter()
-      throws Exception {
-    mockery.checking(new Expectations() {
-      {
-        one(ps).setBigDecimal(with(any(int.class)), with(any(BigDecimal.class)));
-      }
-    });
+  public void shouldSetParameter() throws Exception {
     TYPE_HANDLER.setParameter(ps, 1, new BigDecimal(1), null);
-    mockery.assertIsSatisfied();
+    verify(ps).setBigDecimal(1, new BigDecimal(1));
   }
 
   @Test
-  public void shouldGetResultFromResultSet()
-      throws Exception {
-    mockery.checking(new Expectations() {
-      {
-        one(rs).getBigDecimal(with(any(String.class)));
-        will(returnValue(new BigDecimal(1)));
-        one(rs).wasNull();
-        will(returnValue(false));
-      }
-    });
+  public void shouldGetResultFromResultSet() throws Exception {
+    when(rs.getBigDecimal("column")).thenReturn(new BigDecimal(1));
+    when(rs.wasNull()).thenReturn(false);
     assertEquals(new BigDecimal(1), TYPE_HANDLER.getResult(rs, "column"));
-    mockery.assertIsSatisfied();
   }
 
   @Test
-  public void shouldGetResultFromCallableStatement()
-      throws Exception {
-    mockery.checking(new Expectations() {
-      {
-        one(cs).getBigDecimal(with(any(int.class)));
-        will(returnValue(new BigDecimal(1)));
-        one(cs).wasNull();
-        will(returnValue(false));
-      }
-    });
+  public void shouldGetResultFromCallableStatement() throws Exception {
+    when(cs.getBigDecimal(1)).thenReturn(new BigDecimal(1));
+    when(cs.wasNull()).thenReturn(false);
     assertEquals(new BigDecimal(1), TYPE_HANDLER.getResult(cs, 1));
-    mockery.assertIsSatisfied();
   }
 
-
 }