[waffle-scm] [340] trunk/core/src/test/java/org/codehaus/waffle/action: Migrated or completed migration of other unit tests to jMock 2.

Sat, 03 Nov 2007 08:43:17 -0800

Title: [waffle-scm] [340] trunk/core/src/test/java/org/codehaus/waffle/action: Migrated or completed migration of other unit tests to jMock 2.

Diff

Modified: trunk/core/src/test/java/org/codehaus/waffle/action/HierarchicalArgumentResolverTest.java (339 => 340)

--- trunk/core/src/test/java/org/codehaus/waffle/action/HierarchicalArgumentResolverTest.java	2007-11-03 16:02:00 UTC (rev 339)
+++ trunk/core/src/test/java/org/codehaus/waffle/action/HierarchicalArgumentResolverTest.java	2007-11-03 16:43:13 UTC (rev 340)
@@ -1,136 +1,152 @@
 package org.codehaus.waffle.action;
 
-import org.jmock.Mock;
-import org.jmock.MockObjectTestCase;
-import org.codehaus.waffle.action.ArgumentResolver;
-import org.codehaus.waffle.action.HierarchicalArgumentResolver;
+import static org.junit.Assert.assertEquals;
 
 import javax.servlet.ServletContext;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpSession;
 
-public class HierarchicalArgumentResolverTest extends MockObjectTestCase {
+import org.jmock.Expectations;
+import org.jmock.Mockery;
+import org.jmock.integration.junit4.JMock;
+import org.junit.Test;
+import org.junit.runner.RunWith;
 
+/**
+ * 
+ * @author Michael Ward
+ * @author Mauro Talevi
+ */
[EMAIL PROTECTED](JMock.class)
+public class HierarchicalArgumentResolverTest {
+
+    private Mockery mockery = new Mockery();
+
+    @Test
     public void testResolveReturnsNameWhenArgumentNotInCurlyBrackets() {
         ArgumentResolver argumentResolver = new HierarchicalArgumentResolver(null);
         assertEquals("foobar", argumentResolver.resolve(null, "foobar"));
     }
 
-    public void testResolveFoundInParameter() {
-        // Mock Request
-        Mock mockRequest = mock(HttpServletRequest.class);
-        mockRequest.expects(once())
-                .method("getParameter")
-                .with(eq("foo"))
-                .will(returnValue("bar"));
-        HttpServletRequest request = (HttpServletRequest) mockRequest.proxy();
+    @Test
+    public void canResolveArgumentFoundInParameter() {
+        // Mock HttpServletRequest
+        final HttpServletRequest request = mockery.mock(HttpServletRequest.class);
+        mockery.checking(new Expectations() {
+            {
+                one(request).getParameter("foo");
+                will(returnValue("bar"));
+            }
+        });
 
         ArgumentResolver argumentResolver = new HierarchicalArgumentResolver(null);
         assertEquals("bar", argumentResolver.resolve(request, "{foo}"));
     }
 
-    public void testResolveFoundInRequestAttribute() {
-        // Mock Request
-        Mock mockRequest = mock(HttpServletRequest.class);
-        mockRequest.expects(once())
-                .method("getParameter")
-                .with(eq("foo"))
-                .will(returnValue(null));
-        mockRequest.expects(once())
-                .method("getAttribute")
-                .with(eq("foo"))
-                .will(returnValue("bar"));
-        HttpServletRequest request = (HttpServletRequest) mockRequest.proxy();
+    @Test
+    public void canResolveArgumentFoundInAttribute() {
+        // Mock HttpServletRequest
+        final HttpServletRequest request = mockery.mock(HttpServletRequest.class);
+        mockery.checking(new Expectations() {
+            {
+                one(request).getParameter("foo");
+                will(returnValue(null));
+                one(request).getAttribute("foo");
+                will(returnValue("bar"));
+            }
+        });
 
         ArgumentResolver argumentResolver = new HierarchicalArgumentResolver(null);
         assertEquals("bar", argumentResolver.resolve(request, "{foo}"));
     }
 
-    public void testResolveFoundInSessionAttribute() {
+    @Test
+    public void canResolveArgumentFoundInSessionAttribute() {
         // Mock HttpSession
-        Mock mockSession = mock(HttpSession.class);
-        mockSession.expects(once())
-                .method("getAttribute")
-                .with(eq("foo"))
-                .will(returnValue("bar"));
-        HttpSession session = (HttpSession) mockSession.proxy();
+        final HttpSession session = mockery.mock(HttpSession.class);
+        mockery.checking(new Expectations() {
+            {
+                one(session).getAttribute("foo");
+                will(returnValue("bar"));
+            }
+        });
 
         // Mock HttpServletRequest
-        Mock mockRequest = mock(HttpServletRequest.class);
-        mockRequest.expects(once())
-                .method("getParameter")
-                .with(eq("foo"))
-                .will(returnValue(null));
-        mockRequest.expects(once())
-                .method("getAttribute")
-                .with(eq("foo"))
-                .will(returnValue(null));
-        mockRequest.expects(once())
-                .method("getSession")
-                .will(returnValue(session));
-        HttpServletRequest request = (HttpServletRequest) mockRequest.proxy();
-
+        final HttpServletRequest request = mockery.mock(HttpServletRequest.class);
+        mockery.checking(new Expectations() {
+            {
+                one(request).getParameter("foo");
+                will(returnValue(null));
+                one(request).getAttribute("foo");
+                will(returnValue(null));
+                one(request).getSession();
+                will(returnValue(session));
+            }
+        });
         ArgumentResolver argumentResolver = new HierarchicalArgumentResolver(null);
         assertEquals("bar", argumentResolver.resolve(request, "{foo}"));
     }
 
-    public void testResolveFoundInServletContext() {
-        Mock mockServletContext = mock(ServletContext.class);
-        mockServletContext.expects(once())
-                .method("getAttribute")
-                .with(eq("foo"))
-                .will(returnValue("bar"));
-        ServletContext servletContext = (ServletContext) mockServletContext.proxy();
+    @Test
+    public void canResolveArgumentFoundInServletContext() {
+        // Mock ServletContext
+        final ServletContext servletContext = mockery.mock(ServletContext.class);
+        mockery.checking(new Expectations() {
+            {
+                one(servletContext).getAttribute("foo");
+                will(returnValue("bar"));
+            }
+        });
 
         // Mock HttpSession
-        Mock mockSession = mock(HttpSession.class);
-        mockSession.expects(once())
-                .method("getAttribute")
-                .with(eq("foo"))
-                .will(returnValue(null));
-        HttpSession session = (HttpSession) mockSession.proxy();
+        final HttpSession session = mockery.mock(HttpSession.class);
+        mockery.checking(new Expectations() {
+            {
+                one(session).getAttribute("foo");
+                will(returnValue(null));
+            }
+        });
 
         // Mock HttpServletRequest
-        Mock mockRequest = mock(HttpServletRequest.class);
-        mockRequest.expects(once())
-                .method("getParameter")
-                .with(eq("foo"))
-                .will(returnValue(null));
-        mockRequest.expects(once())
-                .method("getAttribute")
-                .with(eq("foo"))
-                .will(returnValue(null));
-        mockRequest.expects(once())
-                .method("getSession")
-                .will(returnValue(session));
-        HttpServletRequest request = (HttpServletRequest) mockRequest.proxy();
+        final HttpServletRequest request = mockery.mock(HttpServletRequest.class);
+        mockery.checking(new Expectations() {
+            {
+                one(request).getParameter("foo");
+                will(returnValue(null));
+                one(request).getAttribute("foo");
+                will(returnValue(null));
+                one(request).getSession();
+                will(returnValue(session));
+            }
+        });
 
         ArgumentResolver argumentResolver = new HierarchicalArgumentResolver(servletContext);
         assertEquals("bar", argumentResolver.resolve(request, "{foo}"));
     }
 
-    public void testResolveFoundInServletContextWhenSessionIsNull() {
-        Mock mockServletContext = mock(ServletContext.class);
-        mockServletContext.expects(once())
-                .method("getAttribute")
-                .with(eq("foo"))
-                .will(returnValue("bar"));
-        ServletContext servletContext = (ServletContext) mockServletContext.proxy();
+    @Test
+    public void canResolveArgumentFoundInServletContextWhenSessionIsNull() {
+        // Mock ServletContext
+        final ServletContext servletContext = mockery.mock(ServletContext.class);
+        mockery.checking(new Expectations() {
+            {
+                one(servletContext).getAttribute("foo");
+                will(returnValue("bar"));
+            }
+        });
 
         // Mock HttpServletRequest
-        Mock mockRequest = mock(HttpServletRequest.class);
-        mockRequest.expects(once())
-                .method("getParameter")
-                .with(eq("foo"))
-                .will(returnValue(null));
-        mockRequest.expects(once())
-                .method("getAttribute")
-                .with(eq("foo"))
-                .will(returnValue(null));
-        mockRequest.expects(once())
-                .method("getSession")
-                .will(returnValue(null));
-        HttpServletRequest request = (HttpServletRequest) mockRequest.proxy();
+        final HttpServletRequest request = mockery.mock(HttpServletRequest.class);
+        mockery.checking(new Expectations() {
+            {
+                one(request).getParameter("foo");
+                will(returnValue(null));
+                one(request).getAttribute("foo");
+                will(returnValue(null));
+                one(request).getSession();
+                will(returnValue(null));
+            }
+        });
 
         ArgumentResolver argumentResolver = new HierarchicalArgumentResolver(servletContext);
         assertEquals("bar", argumentResolver.resolve(request, "{foo}"));

Modified: trunk/core/src/test/java/org/codehaus/waffle/action/ParanamerMethodDefinitionFinderTest.java (339 => 340)

--- trunk/core/src/test/java/org/codehaus/waffle/action/ParanamerMethodDefinitionFinderTest.java	2007-11-03 16:02:00 UTC (rev 339)
+++ trunk/core/src/test/java/org/codehaus/waffle/action/ParanamerMethodDefinitionFinderTest.java	2007-11-03 16:43:13 UTC (rev 340)
@@ -19,6 +19,7 @@
 import java.util.Collections;
 import java.util.List;
 
+//TODO refactor this test to re-use the AnnotatedMethodDefinitionTest
 public class ParanamerMethodDefinitionFinderTest extends MockObjectTestCase {
 
     private ActionMonitor monitor = new SilentMonitor();

Modified: trunk/core/src/test/java/org/codehaus/waffle/action/RequestParameterMethodNameResolverTest.java (339 => 340)

--- trunk/core/src/test/java/org/codehaus/waffle/action/RequestParameterMethodNameResolverTest.java	2007-11-03 16:02:00 UTC (rev 339)
+++ trunk/core/src/test/java/org/codehaus/waffle/action/RequestParameterMethodNameResolverTest.java	2007-11-03 16:43:13 UTC (rev 340)
@@ -1,5 +1,7 @@
 package org.codehaus.waffle.action;
 
+import static org.junit.Assert.assertEquals;
+
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Map;
@@ -8,38 +10,53 @@
 
 import org.codehaus.waffle.monitor.ActionMonitor;
 import org.codehaus.waffle.monitor.SilentMonitor;
-import org.jmock.Mock;
-import org.jmock.MockObjectTestCase;
+import org.jmock.Expectations;
+import org.jmock.Mockery;
+import org.jmock.integration.junit4.JMock;
+import org.junit.Test;
+import org.junit.runner.RunWith;
 
-public class RequestParameterMethodNameResolverTest extends MockObjectTestCase {
-
+/**
+ * 
+ * @author Michael Ward
+ * @author Mauro Talevi
+ */
[EMAIL PROTECTED](JMock.class)
+public class RequestParameterMethodNameResolverTest {
+    
+    private Mockery mockery = new Mockery();
+    
     private ActionMonitor monitor = new SilentMonitor();
 
-    public void testResolve() {
-        Mock mockRequest = mock(HttpServletRequest.class);
-        mockRequest.expects(once())
-                .method("getParameter")
-                .with(eq("method"))
-                .will(returnValue("foobar"));
-        mockRequest.expects(once())
-                .method("getParameterMap")
-                .will(returnValue(mockParameterMap("method")));
-        HttpServletRequest request = (HttpServletRequest) mockRequest.proxy();
+    @Test
+    public void canResolve() {
+        // Mock HttpServletRequest
+        final HttpServletRequest request = mockery.mock(HttpServletRequest.class);
+        mockery.checking(new Expectations() {
+            {
+                one(request).getParameter("method");
+                will(returnValue("foobar"));
+                one(request).getParameterMap();
+                will(returnValue(mockParameterMap("method")));
+            }
+        });
 
         MethodNameResolver resolver = new RequestParameterMethodNameResolver(monitor);
         assertEquals("foobar", resolver.resolve(request));
     }
 
-    public void testResolveWithAlternateConfiguration() {
-        Mock mockRequest = mock(HttpServletRequest.class);
-        mockRequest.expects(once())
-                .method("getParameter")
-                .with(eq("soda"))
-                .will(returnValue("foobar"));
-        mockRequest.expects(once())
-                .method("getParameterMap")
-                .will(returnValue(mockParameterMap("soda")));
-        HttpServletRequest request = (HttpServletRequest) mockRequest.proxy();
+    @Test
+    public void canResolveWithAlternateConfiguration() {
+        // Mock HttpServletRequest
+        final HttpServletRequest request = mockery.mock(HttpServletRequest.class);
+        mockery.checking(new Expectations() {
+            {
+                one(request).getParameter("soda");
+                will(returnValue("foobar"));
+                one(request).getParameterMap();
+                will(returnValue(mockParameterMap("soda")));
+            }
+        });
 
         RequestParameterMethodNameResolverConfig configuration = new RequestParameterMethodNameResolverConfig() {
             public String getMethodParameterKey() {
@@ -52,12 +69,16 @@
     }
     
     @SuppressWarnings({"unchecked"})
-    private Map mockParameterMap(String name) {
-        Mock mockMap = mock(Map.class);
-        mockMap.expects(once())
-                .method("keySet")
-                .will(returnValue(new HashSet(Arrays.asList(new String[]{name}))));
-        return (Map) mockMap.proxy();
+    private Map mockParameterMap(final String name) {
+        // Mock Map
+        final Map map = mockery.mock(Map.class);
+        mockery.checking(new Expectations() {
+            {
+                one(map).keySet();
+                will(returnValue(new HashSet(Arrays.asList(new String[]{name}))));
+            }
+        });
+        return map;
     }

To unsubscribe from this list please visit:

http://xircles.codehaus.org/manage_email

Reply via email to