You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@shiro.apache.org by bm...@apache.org on 2021/01/25 20:19:14 UTC
[shiro] branch master updated (555fe06 -> e5d8134)
This is an automated email from the ASF dual-hosted git repository.
bmarwell pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/shiro.git.
from 555fe06 Merge pull request #283 from bmarwell/jenkins_pr
new 1b0ff3e [SHIRO-811] fix toggling test through Mockito conversion.
new e5d8134 [SHIRO-811] convert more tests to Mockito
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../SubjectAwareExecutorServiceTest.java | 31 ++--
.../shiro/concurrent/SubjectAwareExecutorTest.java | 25 ++-
.../authc/BasicHttpAuthenticationFilter.java | 4 +-
.../test/java/org/apache/shiro/web/WebTest.java | 12 +-
.../authc/BasicHttpFilterAuthenticationTest.java | 199 +++++++++------------
.../web/filter/authz/AuthorizationFilterTest.java | 34 ++--
.../mgt/PathMatchingFilterChainResolverTest.java | 121 ++++++-------
.../web/mgt/DefaultWebSecurityManagerTest.java | 80 ++++-----
.../web/servlet/ShiroHttpServletRequestTest.java | 79 ++++----
9 files changed, 279 insertions(+), 306 deletions(-)
[shiro] 02/02: [SHIRO-811] convert more tests to Mockito
Posted by bm...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
bmarwell pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/shiro.git
commit e5d8134d9457c87e63f97b441255012686a3056f
Author: Benjamin Marwell <bm...@apache.org>
AuthorDate: Mon Jan 25 17:11:44 2021 +0100
[SHIRO-811] convert more tests to Mockito
---
.../test/java/org/apache/shiro/web/WebTest.java | 12 +-
.../mgt/PathMatchingFilterChainResolverTest.java | 121 ++++++++++-----------
.../web/mgt/DefaultWebSecurityManagerTest.java | 80 ++++++--------
.../web/servlet/ShiroHttpServletRequestTest.java | 79 ++++++++------
4 files changed, 142 insertions(+), 150 deletions(-)
diff --git a/web/src/test/java/org/apache/shiro/web/WebTest.java b/web/src/test/java/org/apache/shiro/web/WebTest.java
index 22eeacc..25ced2f 100644
--- a/web/src/test/java/org/apache/shiro/web/WebTest.java
+++ b/web/src/test/java/org/apache/shiro/web/WebTest.java
@@ -18,21 +18,21 @@
*/
package org.apache.shiro.web;
-import static org.easymock.EasyMock.createNiceMock;
-import static org.easymock.EasyMock.expect;
-
import javax.servlet.FilterConfig;
import javax.servlet.ServletContext;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
/**
* @since 1.0
*/
public abstract class WebTest {
protected FilterConfig createNiceMockFilterConfig() {
- FilterConfig mock = createNiceMock(FilterConfig.class);
- ServletContext mockServletContext = createNiceMock(ServletContext.class);
- expect(mock.getServletContext()).andReturn(mockServletContext);
+ FilterConfig mock = mock(FilterConfig.class);
+ ServletContext mockServletContext = mock(ServletContext.class);
+ when(mock.getServletContext()).thenReturn(mockServletContext);
return mock;
}
diff --git a/web/src/test/java/org/apache/shiro/web/filter/mgt/PathMatchingFilterChainResolverTest.java b/web/src/test/java/org/apache/shiro/web/filter/mgt/PathMatchingFilterChainResolverTest.java
index f13e8ea..90f5977 100644
--- a/web/src/test/java/org/apache/shiro/web/filter/mgt/PathMatchingFilterChainResolverTest.java
+++ b/web/src/test/java/org/apache/shiro/web/filter/mgt/PathMatchingFilterChainResolverTest.java
@@ -30,8 +30,13 @@ import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
-import static org.easymock.EasyMock.*;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
/**
* Tests for {@link org.apache.shiro.web.filter.mgt.PathMatchingFilterChainResolver}.
@@ -58,14 +63,12 @@ public class PathMatchingFilterChainResolverTest extends WebTest {
@Test
public void testNewInstanceWithFilterConfig() {
FilterConfig mock = createNiceMockFilterConfig();
- replay(mock);
resolver = new PathMatchingFilterChainResolver(mock);
assertNotNull(resolver.getPathMatcher());
assertTrue(resolver.getPathMatcher() instanceof AntPathMatcher);
assertNotNull(resolver.getFilterChainManager());
assertTrue(resolver.getFilterChainManager() instanceof DefaultFilterChainManager);
assertEquals(((DefaultFilterChainManager) resolver.getFilterChainManager()).getFilterConfig(), mock);
- verify(mock);
}
@Test
@@ -80,82 +83,78 @@ public class PathMatchingFilterChainResolverTest extends WebTest {
@Test
public void testGetChainsWithoutChains() {
- ServletRequest request = createNiceMock(HttpServletRequest.class);
- ServletResponse response = createNiceMock(HttpServletResponse.class);
- FilterChain chain = createNiceMock(FilterChain.class);
+ ServletRequest request = mock(HttpServletRequest.class);
+ ServletResponse response = mock(HttpServletResponse.class);
+ FilterChain chain = mock(FilterChain.class);
FilterChain resolved = resolver.getChain(request, response, chain);
assertNull(resolved);
}
@Test
public void testGetChainsWithMatch() {
- HttpServletRequest request = createNiceMock(HttpServletRequest.class);
- HttpServletResponse response = createNiceMock(HttpServletResponse.class);
- FilterChain chain = createNiceMock(FilterChain.class);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ HttpServletResponse response = mock(HttpServletResponse.class);
+ FilterChain chain = mock(FilterChain.class);
//ensure at least one chain is defined:
resolver.getFilterChainManager().addToChain("/index.html", "authcBasic");
- expect(request.getServletPath()).andReturn("");
- expect(request.getPathInfo()).andReturn("/index.html");
- replay(request);
+ when(request.getServletPath()).thenReturn("");
+ when(request.getPathInfo()).thenReturn("/index.html");
FilterChain resolved = resolver.getChain(request, response, chain);
assertNotNull(resolved);
- verify(request);
+ verify(request).getServletPath();
}
@Test
public void testPathTraversalWithDot() {
- HttpServletRequest request = createNiceMock(HttpServletRequest.class);
- HttpServletResponse response = createNiceMock(HttpServletResponse.class);
- FilterChain chain = createNiceMock(FilterChain.class);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ HttpServletResponse response = mock(HttpServletResponse.class);
+ FilterChain chain = mock(FilterChain.class);
//ensure at least one chain is defined:
resolver.getFilterChainManager().addToChain("/index.html", "authcBasic");
- expect(request.getServletPath()).andReturn("/");
- expect(request.getPathInfo()).andReturn("./index.html");
- replay(request);
+ when(request.getServletPath()).thenReturn("/");
+ when(request.getPathInfo()).thenReturn("./index.html");
FilterChain resolved = resolver.getChain(request, response, chain);
assertNotNull(resolved);
- verify(request);
+ verify(request).getServletPath();
}
@Test
public void testPathTraversalWithDotDot() {
- HttpServletRequest request = createNiceMock(HttpServletRequest.class);
- HttpServletResponse response = createNiceMock(HttpServletResponse.class);
- FilterChain chain = createNiceMock(FilterChain.class);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ HttpServletResponse response = mock(HttpServletResponse.class);
+ FilterChain chain = mock(FilterChain.class);
//ensure at least one chain is defined:
resolver.getFilterChainManager().addToChain("/index.html", "authcBasic");
- expect(request.getServletPath()).andReturn("/public/");
- expect(request.getPathInfo()).andReturn("../index.html");
- replay(request);
+ when(request.getServletPath()).thenReturn("/public/");
+ when(request.getPathInfo()).thenReturn("../index.html");
FilterChain resolved = resolver.getChain(request, response, chain);
assertNotNull(resolved);
- verify(request);
+ verify(request).getServletPath();
}
@Test
public void testGetChainsWithoutMatch() {
- HttpServletRequest request = createNiceMock(HttpServletRequest.class);
- HttpServletResponse response = createNiceMock(HttpServletResponse.class);
- FilterChain chain = createNiceMock(FilterChain.class);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ HttpServletResponse response = mock(HttpServletResponse.class);
+ FilterChain chain = mock(FilterChain.class);
//ensure at least one chain is defined:
resolver.getFilterChainManager().addToChain("/index.html", "authcBasic");
- expect(request.getServletPath()).andReturn("/");
- expect(request.getPathInfo()).andReturn(null);
- replay(request);
+ when(request.getServletPath()).thenReturn("/");
+ when(request.getPathInfo()).thenReturn(null);
FilterChain resolved = resolver.getChain(request, response, chain);
assertNull(resolved);
- verify(request);
+ verify(request).getServletPath();
}
/**
@@ -163,20 +162,19 @@ public class PathMatchingFilterChainResolverTest extends WebTest {
*/
@Test
public void testGetChain() {
- HttpServletRequest request = createNiceMock(HttpServletRequest.class);
- HttpServletResponse response = createNiceMock(HttpServletResponse.class);
- FilterChain chain = createNiceMock(FilterChain.class);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ HttpServletResponse response = mock(HttpServletResponse.class);
+ FilterChain chain = mock(FilterChain.class);
//ensure at least one chain is defined:
resolver.getFilterChainManager().addToChain("/resource/book", "authcBasic");
- expect(request.getServletPath()).andReturn("");
- expect(request.getPathInfo()).andReturn("/resource/book");
- replay(request);
+ when(request.getServletPath()).thenReturn("");
+ when(request.getPathInfo()).thenReturn("/resource/book");
FilterChain resolved = resolver.getChain(request, response, chain);
assertNotNull(resolved);
- verify(request);
+ verify(request).getServletPath();
}
/**
@@ -184,20 +182,19 @@ public class PathMatchingFilterChainResolverTest extends WebTest {
*/
@Test
public void testGetChainEqualUrlSeparator() {
- HttpServletRequest request = createNiceMock(HttpServletRequest.class);
- HttpServletResponse response = createNiceMock(HttpServletResponse.class);
- FilterChain chain = createNiceMock(FilterChain.class);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ HttpServletResponse response = mock(HttpServletResponse.class);
+ FilterChain chain = mock(FilterChain.class);
//ensure at least one chain is defined:
resolver.getFilterChainManager().addToChain("/", "authcBasic");
- expect(request.getServletPath()).andReturn("/");
- expect(request.getPathInfo()).andReturn(null);
- replay(request);
+ when(request.getServletPath()).thenReturn("/");
+ when(request.getPathInfo()).thenReturn(null);
FilterChain resolved = resolver.getChain(request, response, chain);
assertNotNull(resolved);
- verify(request);
+ verify(request).getServletPath();
}
/**
@@ -205,20 +202,19 @@ public class PathMatchingFilterChainResolverTest extends WebTest {
*/
@Test
public void testGetChainEndWithUrlSeparator() {
- HttpServletRequest request = createNiceMock(HttpServletRequest.class);
- HttpServletResponse response = createNiceMock(HttpServletResponse.class);
- FilterChain chain = createNiceMock(FilterChain.class);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ HttpServletResponse response = mock(HttpServletResponse.class);
+ FilterChain chain = mock(FilterChain.class);
//ensure at least one chain is defined:
resolver.getFilterChainManager().addToChain("/resource/book", "authcBasic");
- expect(request.getServletPath()).andReturn("");
- expect(request.getPathInfo()).andReturn("/resource/book");
- replay(request);
+ when(request.getServletPath()).thenReturn("");
+ when(request.getPathInfo()).thenReturn("/resource/book");
FilterChain resolved = resolver.getChain(request, response, chain);
assertNotNull(resolved);
- verify(request);
+ verify(request).getServletPath();
}
/**
@@ -226,19 +222,18 @@ public class PathMatchingFilterChainResolverTest extends WebTest {
*/
@Test
public void testGetChainEndWithMultiUrlSeparator() {
- HttpServletRequest request = createNiceMock(HttpServletRequest.class);
- HttpServletResponse response = createNiceMock(HttpServletResponse.class);
- FilterChain chain = createNiceMock(FilterChain.class);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ HttpServletResponse response = mock(HttpServletResponse.class);
+ FilterChain chain = mock(FilterChain.class);
//ensure at least one chain is defined:
resolver.getFilterChainManager().addToChain("/resource/book", "authcBasic");
- expect(request.getServletPath()).andReturn("");
- expect(request.getPathInfo()).andReturn("/resource/book//");
- replay(request);
+ when(request.getServletPath()).thenReturn("");
+ when(request.getPathInfo()).thenReturn("/resource/book//");
FilterChain resolved = resolver.getChain(request, response, chain);
assertNotNull(resolved);
- verify(request);
+ verify(request).getServletPath();
}
}
diff --git a/web/src/test/java/org/apache/shiro/web/mgt/DefaultWebSecurityManagerTest.java b/web/src/test/java/org/apache/shiro/web/mgt/DefaultWebSecurityManagerTest.java
index 21c440b..443b030 100644
--- a/web/src/test/java/org/apache/shiro/web/mgt/DefaultWebSecurityManagerTest.java
+++ b/web/src/test/java/org/apache/shiro/web/mgt/DefaultWebSecurityManagerTest.java
@@ -42,8 +42,16 @@ import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.Serializable;
-import static org.easymock.EasyMock.*;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
/**
* @since 0.9
@@ -62,6 +70,7 @@ public class DefaultWebSecurityManagerTest extends AbstractWebSecurityManagerTes
sm.setRealm(new IniRealm(ini));
}
+ @Override
@After
public void tearDown() {
sm.destroy();
@@ -75,17 +84,15 @@ public class DefaultWebSecurityManagerTest extends AbstractWebSecurityManagerTes
@Test
public void checkSessionManagerDeterminesContainerSessionMode() {
sm.setSessionMode(DefaultWebSecurityManager.NATIVE_SESSION_MODE);
- WebSessionManager sessionManager = createMock(WebSessionManager.class);
+ WebSessionManager sessionManager = mock(WebSessionManager.class);
- expect(sessionManager.isServletContainerSessions()).andReturn(true).anyTimes();
-
- replay(sessionManager);
+ when(sessionManager.isServletContainerSessions()).thenReturn(true);
sm.setSessionManager(sessionManager);
assertTrue("The set SessionManager is not being used to determine isHttpSessionMode.", sm.isHttpSessionMode());
- verify(sessionManager);
+ verify(sessionManager).isServletContainerSessions();
}
@Test
@@ -103,13 +110,12 @@ public class DefaultWebSecurityManagerTest extends AbstractWebSecurityManagerTes
@Test
public void testLogin() {
- HttpServletRequest mockRequest = createNiceMock(HttpServletRequest.class);
- HttpServletResponse mockResponse = createNiceMock(HttpServletResponse.class);
+ HttpServletRequest mockRequest = mock(HttpServletRequest.class);
+ HttpServletResponse mockResponse = mock(HttpServletResponse.class);
- expect(mockRequest.getCookies()).andReturn(null);
- expect(mockRequest.getContextPath()).andReturn("/");
+ when(mockRequest.getCookies()).thenReturn(null);
+ when(mockRequest.getContextPath()).thenReturn("/");
- replay(mockRequest);
Subject subject = newSubject(mockRequest, mockResponse);
@@ -119,7 +125,7 @@ public class DefaultWebSecurityManagerTest extends AbstractWebSecurityManagerTes
assertTrue(subject.isAuthenticated());
assertNotNull(subject.getPrincipal());
- assertTrue(subject.getPrincipal().equals("lonestarr"));
+ assertEquals("lonestarr", subject.getPrincipal());
}
@Test
@@ -128,13 +134,11 @@ public class DefaultWebSecurityManagerTest extends AbstractWebSecurityManagerTes
long globalTimeout = 100;
((AbstractSessionManager) sm.getSessionManager()).setGlobalSessionTimeout(globalTimeout);
- HttpServletRequest mockRequest = createNiceMock(HttpServletRequest.class);
- HttpServletResponse mockResponse = createNiceMock(HttpServletResponse.class);
-
- expect(mockRequest.getCookies()).andReturn(null);
- expect(mockRequest.getContextPath()).andReturn("/");
+ HttpServletRequest mockRequest = mock(HttpServletRequest.class);
+ HttpServletResponse mockResponse = mock(HttpServletResponse.class);
- replay(mockRequest);
+ when(mockRequest.getCookies()).thenReturn(null);
+ when(mockRequest.getContextPath()).thenReturn("/");
Subject subject = newSubject(mockRequest, mockResponse);
@@ -154,22 +158,16 @@ public class DefaultWebSecurityManagerTest extends AbstractWebSecurityManagerTes
public void testGetSubjectByRequestResponsePair() {
shiroSessionModeInit();
- HttpServletRequest mockRequest = createNiceMock(HttpServletRequest.class);
- HttpServletResponse mockResponse = createNiceMock(HttpServletResponse.class);
+ HttpServletRequest mockRequest = mock(HttpServletRequest.class);
+ HttpServletResponse mockResponse = mock(HttpServletResponse.class);
- expect(mockRequest.getCookies()).andReturn(null);
-
- replay(mockRequest);
- replay(mockResponse);
+ when(mockRequest.getCookies()).thenReturn(null);
Subject subject = newSubject(mockRequest, mockResponse);
- verify(mockRequest);
- verify(mockResponse);
-
assertNotNull(subject);
assertTrue(subject.getPrincipals() == null || subject.getPrincipals().isEmpty());
- assertTrue(subject.getSession(false) == null);
+ assertNull(subject.getSession(false));
assertFalse(subject.isAuthenticated());
}
@@ -178,11 +176,8 @@ public class DefaultWebSecurityManagerTest extends AbstractWebSecurityManagerTes
shiroSessionModeInit();
- HttpServletRequest mockRequest = createNiceMock(HttpServletRequest.class);
- HttpServletResponse mockResponse = createNiceMock(HttpServletResponse.class);
-
- replay(mockRequest);
- replay(mockResponse);
+ HttpServletRequest mockRequest = mock(HttpServletRequest.class);
+ HttpServletResponse mockResponse = mock(HttpServletResponse.class);
Subject subject = newSubject(mockRequest, mockResponse);
@@ -191,27 +186,18 @@ public class DefaultWebSecurityManagerTest extends AbstractWebSecurityManagerTes
assertNotNull(sessionId);
- verify(mockRequest);
- verify(mockResponse);
-
- mockRequest = createNiceMock(HttpServletRequest.class);
- mockResponse = createNiceMock(HttpServletResponse.class);
+ mockRequest = mock(HttpServletRequest.class);
+ mockResponse = mock(HttpServletResponse.class);
//now simulate the cookie going with the request and the Subject should be acquired based on that:
Cookie[] cookies = new Cookie[]{new Cookie(ShiroHttpSession.DEFAULT_SESSION_ID_NAME, sessionId.toString())};
- expect(mockRequest.getCookies()).andReturn(cookies).anyTimes();
- expect(mockRequest.getParameter(isA(String.class))).andReturn(null).anyTimes();
-
- replay(mockRequest);
- replay(mockResponse);
+ when(mockRequest.getCookies()).thenReturn(cookies);
+ when(mockRequest.getParameter(any(String.class))).thenReturn(null);
subject = newSubject(mockRequest, mockResponse);
session = subject.getSession(false);
assertNotNull(session);
assertEquals(sessionId, session.getId());
-
- verify(mockRequest);
- verify(mockResponse);
}
/**
diff --git a/web/src/test/java/org/apache/shiro/web/servlet/ShiroHttpServletRequestTest.java b/web/src/test/java/org/apache/shiro/web/servlet/ShiroHttpServletRequestTest.java
index 85da229..b74911a 100644
--- a/web/src/test/java/org/apache/shiro/web/servlet/ShiroHttpServletRequestTest.java
+++ b/web/src/test/java/org/apache/shiro/web/servlet/ShiroHttpServletRequestTest.java
@@ -18,54 +18,64 @@
*/
package org.apache.shiro.web.servlet;
-import static org.easymock.EasyMock.*;
+import org.apache.shiro.session.Session;
+import org.apache.shiro.subject.Subject;
+import org.apache.shiro.util.ThreadContext;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
+import java.util.concurrent.atomic.AtomicInteger;
-import org.apache.shiro.session.Session;
-import org.apache.shiro.subject.Subject;
-import org.apache.shiro.util.ThreadContext;
-import org.junit.Before;
-import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
-import junit.framework.TestCase;
+public class ShiroHttpServletRequestTest {
-public class ShiroHttpServletRequestTest extends TestCase {
+ private ShiroHttpServletRequest request;
- private ShiroHttpServletRequest request;
-
- private HttpServletRequest mockRequest;
- private ServletContext mockContext;
- private Subject mockSubject;
-
- @Before
+ private HttpServletRequest mockRequest = mock(HttpServletRequest.class);
+ private ServletContext mockContext = mock(ServletContext.class);
+ private Subject mockSubject = mock(Subject.class);
+
+ @BeforeEach
public void setUp() throws Exception {
- this.mockRequest = createMock(HttpServletRequest.class);
- this.mockContext = createMock(ServletContext.class);
- this.mockSubject = createMock(Subject.class);
-
- ThreadContext.bind(this.mockSubject);
- this.request = new ShiroHttpServletRequest(mockRequest, mockContext, false);
+ ThreadContext.bind(this.mockSubject);
+ this.request = new ShiroHttpServletRequest(mockRequest, mockContext, false);
}
/**
* Test asserting <a href="https://issues.apache.org/jira/browse/SHIRO-637">SHIRO-637<a/>.
*/
@Test
- public void testRegetSession() throws Exception {
- Session session1 = createMock(Session.class);
- Session session2 = createMock(Session.class);
-
+ public void testRegetSession() {
+ Session session1 = mock(Session.class);
+ Session session2 = mock(Session.class);
+ AtomicInteger counter = new AtomicInteger();
+ AtomicInteger counterFalse = new AtomicInteger();
+
mockSubject.logout();
- expect(mockSubject.getSession(true))
- .andReturn(session1).times(1)
- .andReturn(session2).times(1);
- expect(mockSubject.getSession(false))
- .andReturn(session1).times(2)
- .andReturn(null).times(3);
- replay(mockSubject);
-
+ when(mockSubject.getSession(true)).then(args -> {
+ if (counter.getAndIncrement() == 1) {
+ return session1;
+ }
+
+ return session2;
+ });
+ when(mockSubject.getSession(false)).then(args -> {
+ if (counterFalse.getAndIncrement() < 2) {
+ return session1;
+ }
+
+ return null;
+ });
+
assertNotNull(request.getSession(true));
assertNotNull(request.getSession(false));
@@ -73,6 +83,7 @@ public class ShiroHttpServletRequestTest extends TestCase {
assertNull(request.getSession(false));
assertNotNull(request.getSession(true));
- verify(mockSubject);
+ verify(mockSubject, times(2)).getSession(true);
+ verify(mockSubject, atLeast(3)).getSession(false);
}
}
[shiro] 01/02: [SHIRO-811] fix toggling test through Mockito
conversion.
Posted by bm...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
bmarwell pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/shiro.git
commit 1b0ff3e4434a33406e7198485e9b4009e966a5e7
Author: Benjamin Marwell <bm...@apache.org>
AuthorDate: Fri Jan 22 07:15:01 2021 +0100
[SHIRO-811] fix toggling test through Mockito conversion.
---
.../SubjectAwareExecutorServiceTest.java | 31 ++--
.../shiro/concurrent/SubjectAwareExecutorTest.java | 25 ++-
.../authc/BasicHttpAuthenticationFilter.java | 4 +-
.../authc/BasicHttpFilterAuthenticationTest.java | 199 +++++++++------------
.../web/filter/authz/AuthorizationFilterTest.java | 34 ++--
5 files changed, 137 insertions(+), 156 deletions(-)
diff --git a/core/src/test/java/org/apache/shiro/concurrent/SubjectAwareExecutorServiceTest.java b/core/src/test/java/org/apache/shiro/concurrent/SubjectAwareExecutorServiceTest.java
index 7d6a025..91dd4a2 100644
--- a/core/src/test/java/org/apache/shiro/concurrent/SubjectAwareExecutorServiceTest.java
+++ b/core/src/test/java/org/apache/shiro/concurrent/SubjectAwareExecutorServiceTest.java
@@ -21,10 +21,17 @@ package org.apache.shiro.concurrent;
import org.apache.shiro.subject.support.SubjectRunnable;
import org.apache.shiro.test.SecurityManagerTestSupport;
import org.junit.Test;
+import org.mockito.ArgumentCaptor;
-import java.util.concurrent.*;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
-import static org.easymock.EasyMock.*;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
/**
* Test cases for the {@link SubjectAwareExecutorService} implementation.
@@ -34,40 +41,42 @@ public class SubjectAwareExecutorServiceTest extends SecurityManagerTestSupport
@SuppressWarnings({"unchecked"})
@Test
public void testSubmitRunnable() {
- ExecutorService mockExecutorService = createNiceMock(ExecutorService.class);
- expect(mockExecutorService.submit(isA(SubjectRunnable.class))).andReturn(new DummyFuture());
- replay(mockExecutorService);
+ ExecutorService mockExecutorService = mock(ExecutorService.class);
+ ArgumentCaptor<SubjectRunnable> captor = ArgumentCaptor.forClass(SubjectRunnable.class);
+ when(mockExecutorService.submit(captor.capture())).thenReturn(new DummyFuture<>());
final SubjectAwareExecutorService executor = new SubjectAwareExecutorService(mockExecutorService);
- Runnable testRunnable = new Runnable() {
- public void run() {
- System.out.println("Hello World");
- }
- };
+ Runnable testRunnable = () -> System.out.println("Hello World");
executor.submit(testRunnable);
- verify(mockExecutorService);
+ SubjectRunnable subjectRunnable = captor.getValue();
+ assertNotNull(subjectRunnable);
}
private class DummyFuture<V> implements Future<V> {
+ @Override
public boolean cancel(boolean b) {
return false;
}
+ @Override
public boolean isCancelled() {
return false;
}
+ @Override
public boolean isDone() {
return true;
}
+ @Override
public V get() throws InterruptedException, ExecutionException {
return null;
}
+ @Override
public V get(long l, TimeUnit timeUnit) throws InterruptedException, ExecutionException, TimeoutException {
return null;
}
diff --git a/core/src/test/java/org/apache/shiro/concurrent/SubjectAwareExecutorTest.java b/core/src/test/java/org/apache/shiro/concurrent/SubjectAwareExecutorTest.java
index 29d0148..f872c7a 100644
--- a/core/src/test/java/org/apache/shiro/concurrent/SubjectAwareExecutorTest.java
+++ b/core/src/test/java/org/apache/shiro/concurrent/SubjectAwareExecutorTest.java
@@ -21,10 +21,13 @@ package org.apache.shiro.concurrent;
import org.apache.shiro.subject.support.SubjectRunnable;
import org.apache.shiro.test.SecurityManagerTestSupport;
import org.junit.Test;
+import org.mockito.ArgumentCaptor;
import java.util.concurrent.Executor;
-import static org.easymock.EasyMock.*;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
/**
* Test cases for the {@link SubjectAwareExecutor} implementation.
@@ -35,21 +38,17 @@ public class SubjectAwareExecutorTest extends SecurityManagerTestSupport {
@Test
public void testExecute() {
- Executor targetMockExecutor = createNiceMock(Executor.class);
- //* ensure the target Executor receives a SubjectRunnable instance that retains the subject identity:
- //(this is what verifies the test is valid):
- targetMockExecutor.execute(isA(SubjectRunnable.class));
- replay(targetMockExecutor);
-
+ Executor targetMockExecutor = mock(Executor.class);
final SubjectAwareExecutor executor = new SubjectAwareExecutor(targetMockExecutor);
- Runnable work = new Runnable() {
- public void run() {
- System.out.println("Hello World");
- }
- };
+ Runnable work = () -> System.out.println("Hello World");
executor.execute(work);
- verify(targetMockExecutor);
+ //* ensure the target Executor receives a SubjectRunnable instance that retains the subject identity:
+ //(this is what verifies the test is valid):
+ ArgumentCaptor<SubjectRunnable> subjectRunnableArgumentCaptor = ArgumentCaptor.forClass(SubjectRunnable.class);
+ verify(targetMockExecutor).execute(subjectRunnableArgumentCaptor.capture());
+ SubjectRunnable subjectRunnable = subjectRunnableArgumentCaptor.getValue();
+ assertNotNull(subjectRunnable);
}
}
diff --git a/web/src/main/java/org/apache/shiro/web/filter/authc/BasicHttpAuthenticationFilter.java b/web/src/main/java/org/apache/shiro/web/filter/authc/BasicHttpAuthenticationFilter.java
index 015e692..6b0c08c 100644
--- a/web/src/main/java/org/apache/shiro/web/filter/authc/BasicHttpAuthenticationFilter.java
+++ b/web/src/main/java/org/apache/shiro/web/filter/authc/BasicHttpAuthenticationFilter.java
@@ -82,9 +82,10 @@ public class BasicHttpAuthenticationFilter extends HttpAuthenticationFilter {
* </ol>
*
* @param request incoming ServletRequest
- * @param response outgoing ServletResponse
+ * @param response outgoing ServletResponse (never used)
* @return the AuthenticationToken used to execute the login attempt
*/
+ @Override
protected AuthenticationToken createToken(ServletRequest request, ServletResponse response) {
String authorizationHeader = getAuthzHeader(request);
if (authorizationHeader == null || authorizationHeader.length() == 0) {
@@ -125,6 +126,7 @@ public class BasicHttpAuthenticationFilter extends HttpAuthenticationFilter {
* @param encoded the Base64-encoded username:password value found after the scheme in the header
* @return the username (index 0)/password (index 1) pair obtained from the encoded header data.
*/
+ @Override
protected String[] getPrincipalsAndCredentials(String scheme, String encoded) {
String decoded = Base64.decodeToString(encoded);
return decoded.split(":", 2);
diff --git a/web/src/test/java/org/apache/shiro/web/filter/authc/BasicHttpFilterAuthenticationTest.java b/web/src/test/java/org/apache/shiro/web/filter/authc/BasicHttpFilterAuthenticationTest.java
index ef7fa26..e552deb 100644
--- a/web/src/test/java/org/apache/shiro/web/filter/authc/BasicHttpFilterAuthenticationTest.java
+++ b/web/src/test/java/org/apache/shiro/web/filter/authc/BasicHttpFilterAuthenticationTest.java
@@ -18,17 +18,6 @@
*/
package org.apache.shiro.web.filter.authc;
-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.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.lang.codec.Base64;
@@ -36,6 +25,17 @@ import org.apache.shiro.test.SecurityManagerTestSupport;
import org.junit.Before;
import org.junit.Test;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
/**
* Test case for {@link BasicHttpAuthenticationFilter}.
@@ -52,56 +52,49 @@ public class BasicHttpFilterAuthenticationTest extends SecurityManagerTestSuppor
@Test
public void createTokenNoAuthorizationHeader() throws Exception {
testFilter = new BasicHttpAuthenticationFilter();
- HttpServletRequest request = createMock(HttpServletRequest.class);
- expect(request.getHeader("Authorization")).andReturn(null);
- expect(request.getRemoteHost()).andReturn("localhost");
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ when(request.getHeader("Authorization")).then(args -> null);
+ when(request.getRemoteHost()).then(args -> "localhost");
- HttpServletResponse response = createMock(HttpServletResponse.class);
-
- replay(request);
- replay(response);
+ HttpServletResponse response = mock(HttpServletResponse.class);
AuthenticationToken token = testFilter.createToken(request, response);
assertNotNull(token);
assertTrue("Token is not a username and password token.", token instanceof UsernamePasswordToken);
assertEquals("", token.getPrincipal());
- verify(request);
- verify(response);
+ verify(request).getHeader("Authorization");
+ verify(request).getRemoteHost();
}
@Test
public void createTokenNoUsername() throws Exception {
testFilter = new BasicHttpAuthenticationFilter();
- HttpServletRequest request = createMock(HttpServletRequest.class);
- expect(request.getHeader("Authorization")).andReturn(createAuthorizationHeader("", ""));
- expect(request.getRemoteHost()).andReturn("localhost");
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ when(request.getHeader("Authorization")).then(args -> createAuthorizationHeader("", ""));
+ when(request.getRemoteHost()).then(args -> "localhost");
- HttpServletResponse response = createMock(HttpServletResponse.class);
+ HttpServletResponse response = mock(HttpServletResponse.class);
- replay(request);
- replay(response);
AuthenticationToken token = testFilter.createToken(request, response);
assertNotNull(token);
assertTrue("Token is not a username and password token.", token instanceof UsernamePasswordToken);
assertEquals("", token.getPrincipal());
-
- verify(request);
- verify(response);
+
+ verify(request).getHeader("Authorization");
+ verify(request).getRemoteHost();
}
@Test
public void createTokenNoPassword() throws Exception {
testFilter = new BasicHttpAuthenticationFilter();
- HttpServletRequest request = createMock(HttpServletRequest.class);
- expect(request.getHeader("Authorization")).andReturn(createAuthorizationHeader("pedro", ""));
- expect(request.getRemoteHost()).andReturn("localhost");
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ when(request.getHeader("Authorization")).then(args -> createAuthorizationHeader("pedro", ""));
+ when(request.getRemoteHost()).then(args -> "localhost");
- HttpServletResponse response = createMock(HttpServletResponse.class);
+ HttpServletResponse response = mock(HttpServletResponse.class);
- replay(request);
- replay(response);
AuthenticationToken token = testFilter.createToken(request, response);
assertNotNull(token);
@@ -110,22 +103,20 @@ public class BasicHttpFilterAuthenticationTest extends SecurityManagerTestSuppor
UsernamePasswordToken upToken = (UsernamePasswordToken) token;
assertEquals("pedro", upToken.getUsername());
assertEquals("Password is not empty.", 0, upToken.getPassword().length);
-
- verify(request);
- verify(response);
+
+ verify(request).getHeader("Authorization");
+ verify(request).getRemoteHost();
}
@Test
public void createTokenColonInPassword() throws Exception {
testFilter = new BasicHttpAuthenticationFilter();
- HttpServletRequest request = createMock(HttpServletRequest.class);
- expect(request.getHeader("Authorization")).andReturn(createAuthorizationHeader("pedro", "pass:word"));
- expect(request.getRemoteHost()).andReturn("localhost");
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ when(request.getHeader("Authorization")).then(args -> createAuthorizationHeader("pedro", "pass:word"));
+ when(request.getRemoteHost()).then(args -> "localhost");
- HttpServletResponse response = createMock(HttpServletResponse.class);
+ HttpServletResponse response = mock(HttpServletResponse.class);
- replay(request);
- replay(response);
AuthenticationToken token = testFilter.createToken(request, response);
assertNotNull(token);
@@ -135,20 +126,18 @@ public class BasicHttpFilterAuthenticationTest extends SecurityManagerTestSuppor
assertEquals("pedro", upToken.getUsername());
assertEquals("pass:word", new String(upToken.getPassword()));
- verify(request);
- verify(response);
+ verify(request).getHeader("Authorization");
+ verify(request).getRemoteHost();
}
@Test
public void httpMethodDoesNotRequireAuthentication() throws Exception {
testFilter = new BasicHttpAuthenticationFilter();
- HttpServletRequest request = createMock(HttpServletRequest.class);
- expect(request.getMethod()).andReturn("GET");
- replay(request);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ when(request.getMethod()).then(args -> "GET");
- HttpServletResponse response = createMock(HttpServletResponse.class);
- replay(response);
+ HttpServletResponse response = mock(HttpServletResponse.class);
boolean accessAllowed = testFilter.isAccessAllowed(request, response, new String[] { "POST", "PUT", "DELETE" });
assertTrue("Access not allowed for GET", accessAllowed);
@@ -158,80 +147,72 @@ public class BasicHttpFilterAuthenticationTest extends SecurityManagerTestSuppor
public void httpMethodRequiresAuthentication() throws Exception {
testFilter = new BasicHttpAuthenticationFilter();
- HttpServletRequest request = createMock(HttpServletRequest.class);
- expect(request.getHeader("Authorization")).andReturn(createAuthorizationHeader("pedro", ""));
- expect(request.getRemoteHost()).andReturn("localhost");
- expect(request.getMethod()).andReturn("POST");
- replay(request);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ when(request.getHeader("Authorization")).then(args -> createAuthorizationHeader("pedro", ""));
+ when(request.getRemoteHost()).then(args -> "localhost");
+ when(request.getMethod()).then(args -> "POST");
- HttpServletResponse response = createMock(HttpServletResponse.class);
- replay(response);
+ HttpServletResponse response = mock(HttpServletResponse.class);
boolean accessAllowed = testFilter.isAccessAllowed(request, response, new String[] { "POST", "PUT", "DELETE" });
- assertTrue("Access allowed for POST", !accessAllowed);
+ assertFalse("Access allowed for POST", accessAllowed);
}
@Test
public void httpMethodsAreCaseInsensitive() throws Exception {
testFilter = new BasicHttpAuthenticationFilter();
- HttpServletRequest request = createMock(HttpServletRequest.class);
- expect(request.getMethod()).andReturn("GET");
- expect(request.getMethod()).andReturn("post");
- expect(request.getHeader("Authorization")).andReturn(createAuthorizationHeader("pedro", "")).anyTimes();
- expect(request.getRemoteHost()).andReturn("localhost").anyTimes();
- replay(request);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ when(request.getMethod()).then(args -> "GET");
+ when(request.getHeader("Authorization")).then(args -> createAuthorizationHeader("pedro", ""));
+ when(request.getRemoteHost()).then(args -> "localhost");
- HttpServletResponse response = createMock(HttpServletResponse.class);
- replay(response);
+ HttpServletResponse response = mock(HttpServletResponse.class);
boolean accessAllowed = testFilter.isAccessAllowed(request, response, new String[] { "POST", "put", "delete" });
assertTrue("Access not allowed for GET", accessAllowed);
-
+
+ when(request.getMethod()).then(args -> "post");
accessAllowed = testFilter.isAccessAllowed(request, response, new String[] { "post", "put", "delete" });
- assertTrue("Access allowed for POST", !accessAllowed);
+ assertFalse("Access allowed for POST", accessAllowed);
}
@Test
public void allHttpMethodsRequireAuthenticationIfNoneConfigured() throws Exception {
testFilter = new BasicHttpAuthenticationFilter();
- HttpServletRequest request = createMock(HttpServletRequest.class);
- expect(request.getHeader("Authorization")).andReturn(createAuthorizationHeader("pedro", "")).anyTimes();
- expect(request.getRemoteHost()).andReturn("localhost").anyTimes();
- expect(request.getMethod()).andReturn("GET");
- expect(request.getMethod()).andReturn("POST");
- replay(request);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ when(request.getHeader("Authorization")).then(args -> createAuthorizationHeader("pedro", ""));
+ when(request.getRemoteHost()).then(args -> "localhost");
+ when(request.getMethod()).then(args -> "GET");
+ when(request.getMethod()).then(args -> "POST");
- HttpServletResponse response = createMock(HttpServletResponse.class);
- replay(response);
+ HttpServletResponse response = mock(HttpServletResponse.class);
boolean accessAllowed = testFilter.isAccessAllowed(request, response, new String[0]);
- assertTrue("Access allowed for GET", !accessAllowed);
+ assertFalse("Access allowed for GET", accessAllowed);
accessAllowed = testFilter.isAccessAllowed(request, response, new String[0]);
- assertTrue("Access allowed for POST", !accessAllowed);
+ assertFalse("Access allowed for POST", accessAllowed);
}
@Test
public void allHttpMethodsRequireAuthenticationIfNullConfig() throws Exception {
testFilter = new BasicHttpAuthenticationFilter();
- HttpServletRequest request = createMock(HttpServletRequest.class);
- expect(request.getHeader("Authorization")).andReturn(createAuthorizationHeader("pedro", "")).anyTimes();
- expect(request.getRemoteHost()).andReturn("localhost").anyTimes();
- expect(request.getMethod()).andReturn("GET");
- expect(request.getMethod()).andReturn("POST");
- replay(request);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ when(request.getHeader("Authorization")).then(args -> createAuthorizationHeader("pedro", ""));
+ when(request.getRemoteHost()).then(args -> "localhost");
+ when(request.getMethod()).then(args -> "GET");
+ when(request.getMethod()).then(args -> "POST");
- HttpServletResponse response = createMock(HttpServletResponse.class);
- replay(response);
+ HttpServletResponse response = mock(HttpServletResponse.class);
boolean accessAllowed = testFilter.isAccessAllowed(request, response, null);
- assertTrue("Access allowed for GET", !accessAllowed);
+ assertFalse("Access allowed for GET", accessAllowed);
accessAllowed = testFilter.isAccessAllowed(request, response, null);
- assertTrue("Access allowed for POST", !accessAllowed);
+ assertFalse("Access allowed for POST", accessAllowed);
}
/**
@@ -241,18 +222,16 @@ public class BasicHttpFilterAuthenticationTest extends SecurityManagerTestSuppor
public void permissiveEnabledWithLoginTest() {
testFilter = new BasicHttpAuthenticationFilter();
- HttpServletRequest request = createMock(HttpServletRequest.class);
- expect(request.getHeader("Authorization")).andReturn(createAuthorizationHeader("pedro", "")).anyTimes();
- expect(request.getRemoteHost()).andReturn("localhost").anyTimes();
- expect(request.getMethod()).andReturn("GET");
- replay(request);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ when(request.getHeader("Authorization")).then(args -> createAuthorizationHeader("pedro", ""));
+ when(request.getRemoteHost()).then(args -> "localhost");
+ when(request.getMethod()).then(args -> "GET");
- HttpServletResponse response = createMock(HttpServletResponse.class);
- replay(response);
+ HttpServletResponse response = mock(HttpServletResponse.class);
String[] mappedValue = {"permissive"};
boolean accessAllowed = testFilter.isAccessAllowed(request, response, mappedValue);
- assertTrue("Access allowed for GET", !accessAllowed); // login attempt should always be false
+ assertFalse("Access allowed for GET", accessAllowed); // login attempt should always be false
}
/**
@@ -262,14 +241,12 @@ public class BasicHttpFilterAuthenticationTest extends SecurityManagerTestSuppor
public void permissiveEnabledTest() {
testFilter = new BasicHttpAuthenticationFilter();
- HttpServletRequest request = createMock(HttpServletRequest.class);
- expect(request.getHeader("Authorization")).andReturn(null).anyTimes();
- expect(request.getRemoteHost()).andReturn("localhost").anyTimes();
- expect(request.getMethod()).andReturn("GET");
- replay(request);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ when(request.getHeader("Authorization")).then(args -> null);
+ when(request.getRemoteHost()).then(args -> "localhost");
+ when(request.getMethod()).then(args -> "GET");
- HttpServletResponse response = createMock(HttpServletResponse.class);
- replay(response);
+ HttpServletResponse response = mock(HttpServletResponse.class);
String[] mappedValue = {"permissive"};
boolean accessAllowed = testFilter.isAccessAllowed(request, response, mappedValue);
@@ -283,17 +260,15 @@ public class BasicHttpFilterAuthenticationTest extends SecurityManagerTestSuppor
public void httpMethodRequiresAuthenticationWithPermissive() throws Exception {
testFilter = new BasicHttpAuthenticationFilter();
- HttpServletRequest request = createMock(HttpServletRequest.class);
- expect(request.getHeader("Authorization")).andReturn(createAuthorizationHeader("pedro", ""));
- expect(request.getRemoteHost()).andReturn("localhost");
- expect(request.getMethod()).andReturn("POST");
- replay(request);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ when(request.getHeader("Authorization")).then(args -> createAuthorizationHeader("pedro", ""));
+ when(request.getRemoteHost()).then(args -> "localhost");
+ when(request.getMethod()).then(args -> "POST");
- HttpServletResponse response = createMock(HttpServletResponse.class);
- replay(response);
+ HttpServletResponse response = mock(HttpServletResponse.class);
boolean accessAllowed = testFilter.isAccessAllowed(request, response, new String[] {"permissive", "POST", "PUT", "DELETE" });
- assertTrue("Access allowed for POST", !accessAllowed);
+ assertFalse("Access allowed for POST", accessAllowed);
}
private String createAuthorizationHeader(String username, String password) {
diff --git a/web/src/test/java/org/apache/shiro/web/filter/authz/AuthorizationFilterTest.java b/web/src/test/java/org/apache/shiro/web/filter/authz/AuthorizationFilterTest.java
index dba7cb5..78692cb 100644
--- a/web/src/test/java/org/apache/shiro/web/filter/authz/AuthorizationFilterTest.java
+++ b/web/src/test/java/org/apache/shiro/web/filter/authz/AuthorizationFilterTest.java
@@ -29,7 +29,10 @@ import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
-import static org.easymock.EasyMock.*;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
/**
* Test cases for the {@link AuthorizationFilter} class.
@@ -46,19 +49,17 @@ public class AuthorizationFilterTest extends SecurityManagerTestSupport {
AuthorizationFilter filter = new AuthorizationFilter() {
@Override
- protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue)
- throws Exception {
+ protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
return false; //for this test case
}
};
- HttpServletRequest request = createNiceMock(HttpServletRequest.class);
- HttpServletResponse response = createNiceMock(HttpServletResponse.class);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ HttpServletResponse response = mock(HttpServletResponse.class);
- response.sendError(HttpServletResponse.SC_UNAUTHORIZED);
- replay(response);
+ // response.sendError(HttpServletResponse.SC_UNAUTHORIZED);
filter.onAccessDenied(request, response);
- verify(response);
+ verify(response).sendError(HttpServletResponse.SC_UNAUTHORIZED);
}
@Test
@@ -73,27 +74,22 @@ public class AuthorizationFilterTest extends SecurityManagerTestSupport {
AuthorizationFilter filter = new AuthorizationFilter() {
@Override
- protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue)
- throws Exception {
+ protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
return false; //for this test case
}
};
filter.setUnauthorizedUrl(unauthorizedUrl);
- HttpServletRequest request = createNiceMock(HttpServletRequest.class);
- HttpServletResponse response = createNiceMock(HttpServletResponse.class);
-
- expect(request.getContextPath()).andReturn("/").anyTimes();
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ HttpServletResponse response = mock(HttpServletResponse.class);
String encoded = "/" + unauthorizedUrl;
- expect(response.encodeRedirectURL(unauthorizedUrl)).andReturn(encoded);
+ when(response.encodeRedirectURL(unauthorizedUrl)).thenReturn(encoded);
response.sendRedirect(encoded);
- replay(request);
- replay(response);
filter.onAccessDenied(request, response);
- verify(request);
- verify(response);
+ verify(response, atLeastOnce()).sendRedirect(encoded);
+ verify(response).encodeRedirectURL(unauthorizedUrl);
}
}