This is an automated email from the ASF dual-hosted git repository.
cziegeler pushed a commit to branch master
in repository
https://gitbox.apache.org/repos/asf/sling-org-apache-sling-engine.git
The following commit(s) were added to refs/heads/master by this push:
new b60c725 Update mockito for Java 25, replace jmock with mockito (#104)
b60c725 is described below
commit b60c725156676bb26647400ce01cf31c249060fb
Author: Carsten Ziegeler <[email protected]>
AuthorDate: Tue Nov 10 14:47:23 2026 +0100
Update mockito for Java 25, replace jmock with mockito (#104)
Co-authored-by: Copilot <[email protected]>
---
pom.xml | 29 +--
.../impl/SlingHttpServletRequestImplTest.java | 242 ++++++---------------
.../engine/impl/filter/AbstractFilterTest.java | 81 ++-----
.../impl/filter/AbstractSlingFilterChainTest.java | 5 +-
.../impl/filter/SlingFilterChainHelperTest.java | 15 +-
.../helper/ExternalServletContextWrapperTest.java | 95 +++-----
.../engine/impl/log/ClientAbortExceptionTest.java | 15 +-
.../engine/impl/request/InitResourceTest.java | 80 ++-----
.../sling/engine/impl/request/RequestDataTest.java | 90 ++------
9 files changed, 174 insertions(+), 478 deletions(-)
diff --git a/pom.xml b/pom.xml
index a387509..c0a0e04 100644
--- a/pom.xml
+++ b/pom.xml
@@ -198,34 +198,7 @@
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
- <version>4.6.1</version>
- <scope>test</scope>
- </dependency>
-
- <!-- needed to mock final methods-->
- <dependency>
- <groupId>org.mockito</groupId>
- <artifactId>mockito-inline</artifactId>
- <version>4.6.1</version>
- <scope>test</scope>
- </dependency>
-
- <dependency>
- <groupId>org.jmock</groupId>
- <artifactId>jmock-junit4</artifactId>
- <version>2.13.1</version>
- <scope>test</scope>
- </dependency>
- <dependency>
- <groupId>net.bytebuddy</groupId>
- <artifactId>byte-buddy</artifactId>
- <version>1.14.15</version>
- <scope>test</scope>
- </dependency>
- <dependency>
- <groupId>net.bytebuddy</groupId>
- <artifactId>byte-buddy-agent</artifactId>
- <version>1.14.15</version>
+ <version>5.24.0</version>
<scope>test</scope>
</dependency>
<dependency>
diff --git
a/src/test/java/org/apache/sling/engine/impl/SlingHttpServletRequestImplTest.java
b/src/test/java/org/apache/sling/engine/impl/SlingHttpServletRequestImplTest.java
index b810889..7c22ddd 100644
---
a/src/test/java/org/apache/sling/engine/impl/SlingHttpServletRequestImplTest.java
+++
b/src/test/java/org/apache/sling/engine/impl/SlingHttpServletRequestImplTest.java
@@ -27,10 +27,6 @@ import org.apache.sling.api.request.RequestPathInfo;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.engine.impl.request.ContentData;
import org.apache.sling.engine.impl.request.RequestData;
-import org.jmock.Expectations;
-import org.jmock.Mockery;
-import org.jmock.imposters.ByteBuddyClassImposteriser;
-import org.jmock.integration.junit4.JUnit4Mockery;
import org.junit.Test;
import org.mockito.Mockito;
@@ -44,218 +40,120 @@ public class SlingHttpServletRequestImplTest {
SlingJakartaHttpServletRequestImpl slingHttpServletRequestImpl;
- private Mockery context = new JUnit4Mockery() {
- {
- setImposteriser(ByteBuddyClassImposteriser.INSTANCE);
- }
- };
-
@Test
public void getUserPrincipal_testWithRemoteUserFallback() {
- final HttpServletRequest servletRequest =
context.mock(HttpServletRequest.class);
-
- context.checking(new Expectations() {
- {
- oneOf(servletRequest).getServletPath();
- will(returnValue("/path"));
- allowing(servletRequest).getPathInfo();
- will(returnValue("/path"));
- allowing(servletRequest).getRemoteUser();
- will(returnValue("remoteUser"));
- }
- });
-
- final RequestData requestData = context.mock(RequestData.class,
"requestData");
- final ResourceResolver resourceResolver =
context.mock(ResourceResolver.class);
-
- context.checking(new Expectations() {
- {
- allowing(requestData).getResourceResolver();
- will(returnValue(resourceResolver));
- allowing(resourceResolver).adaptTo(Principal.class);
- will(returnValue(null));
-
allowing(requestData).isDisableCheckCompliantGetUserPrincipal();
- will(returnValue(false));
- }
- });
+ final HttpServletRequest servletRequest =
Mockito.mock(HttpServletRequest.class);
+ Mockito.when(servletRequest.getServletPath()).thenReturn("/path");
+ Mockito.when(servletRequest.getPathInfo()).thenReturn("/path");
+ Mockito.when(servletRequest.getRemoteUser()).thenReturn("remoteUser");
+
+ final RequestData requestData = Mockito.mock(RequestData.class);
+ final ResourceResolver resourceResolver =
Mockito.mock(ResourceResolver.class);
+
Mockito.when(requestData.getResourceResolver()).thenReturn(resourceResolver);
+
Mockito.when(resourceResolver.adaptTo(Principal.class)).thenReturn(null);
+
Mockito.when(requestData.isDisableCheckCompliantGetUserPrincipal()).thenReturn(false);
slingHttpServletRequestImpl = new
SlingJakartaHttpServletRequestImpl(requestData, servletRequest);
assertEquals(
"UserPrincipal: remoteUser",
slingHttpServletRequestImpl.getUserPrincipal().toString());
+ Mockito.verify(servletRequest).getServletPath();
}
@Test
public void getUserPrincipal_testWithRemoteUserFallback_nonspeccompliant()
{
- final HttpServletRequest servletRequest =
context.mock(HttpServletRequest.class);
-
- context.checking(new Expectations() {
- {
- oneOf(servletRequest).getServletPath();
- will(returnValue("/path"));
- allowing(servletRequest).getPathInfo();
- will(returnValue("/path"));
- allowing(servletRequest).getRemoteUser();
- will(returnValue("remoteUser"));
- }
- });
-
- final RequestData requestData = context.mock(RequestData.class,
"requestData");
- final ResourceResolver resourceResolver =
context.mock(ResourceResolver.class);
-
- context.checking(new Expectations() {
- {
- allowing(requestData).getResourceResolver();
- will(returnValue(resourceResolver));
- allowing(resourceResolver).adaptTo(Principal.class);
- will(returnValue(null));
-
allowing(requestData).isDisableCheckCompliantGetUserPrincipal();
- will(returnValue(true));
- allowing(requestData).logNonCompliantGetUserPrincipalWarning();
- }
- });
+ final HttpServletRequest servletRequest =
Mockito.mock(HttpServletRequest.class);
+ Mockito.when(servletRequest.getServletPath()).thenReturn("/path");
+ Mockito.when(servletRequest.getPathInfo()).thenReturn("/path");
+ Mockito.when(servletRequest.getRemoteUser()).thenReturn("remoteUser");
+
+ final RequestData requestData = Mockito.mock(RequestData.class);
+ final ResourceResolver resourceResolver =
Mockito.mock(ResourceResolver.class);
+
Mockito.when(requestData.getResourceResolver()).thenReturn(resourceResolver);
+
Mockito.when(resourceResolver.adaptTo(Principal.class)).thenReturn(null);
+
Mockito.when(requestData.isDisableCheckCompliantGetUserPrincipal()).thenReturn(true);
slingHttpServletRequestImpl = new
SlingJakartaHttpServletRequestImpl(requestData, servletRequest);
assertEquals(
"UserPrincipal: remoteUser",
slingHttpServletRequestImpl.getUserPrincipal().toString());
+ Mockito.verify(servletRequest).getServletPath();
}
@Test
public void getUserPrincipal_testUnauthenticated() {
- final HttpServletRequest servletRequest =
context.mock(HttpServletRequest.class);
-
- context.checking(new Expectations() {
- {
- oneOf(servletRequest).getServletPath();
- will(returnValue("/path"));
- allowing(servletRequest).getPathInfo();
- will(returnValue("/path"));
- allowing(servletRequest).getRemoteUser();
- will(returnValue(null));
- }
- });
-
- final RequestData requestData = context.mock(RequestData.class,
"requestData");
- final ResourceResolver resourceResolver =
context.mock(ResourceResolver.class);
- final Principal principal = context.mock(Principal.class);
-
- context.checking(new Expectations() {
- {
- allowing(requestData).getResourceResolver();
- will(returnValue(resourceResolver));
- allowing(resourceResolver).adaptTo(Principal.class);
- will(returnValue(principal));
-
allowing(requestData).isDisableCheckCompliantGetUserPrincipal();
- will(returnValue(false));
- }
- });
+ final HttpServletRequest servletRequest =
Mockito.mock(HttpServletRequest.class);
+ Mockito.when(servletRequest.getServletPath()).thenReturn("/path");
+ Mockito.when(servletRequest.getPathInfo()).thenReturn("/path");
+ Mockito.when(servletRequest.getRemoteUser()).thenReturn(null);
+
+ final RequestData requestData = Mockito.mock(RequestData.class);
+ final ResourceResolver resourceResolver =
Mockito.mock(ResourceResolver.class);
+ final Principal principal = Mockito.mock(Principal.class);
+
Mockito.when(requestData.getResourceResolver()).thenReturn(resourceResolver);
+
Mockito.when(resourceResolver.adaptTo(Principal.class)).thenReturn(principal);
+
Mockito.when(requestData.isDisableCheckCompliantGetUserPrincipal()).thenReturn(false);
slingHttpServletRequestImpl = new
SlingJakartaHttpServletRequestImpl(requestData, servletRequest);
assertNull(slingHttpServletRequestImpl.getUserPrincipal());
+ Mockito.verify(servletRequest).getServletPath();
}
@Test
public void getUserPrincipal_testUnauthenticated_nonspeccompliant() {
- final HttpServletRequest servletRequest =
context.mock(HttpServletRequest.class);
-
- context.checking(new Expectations() {
- {
- oneOf(servletRequest).getServletPath();
- will(returnValue("/path"));
- allowing(servletRequest).getPathInfo();
- will(returnValue("/path"));
- allowing(servletRequest).getRemoteUser();
- will(returnValue(null));
- }
- });
-
- final RequestData requestData = context.mock(RequestData.class,
"requestData");
- final ResourceResolver resourceResolver =
context.mock(ResourceResolver.class);
- final Principal principal = context.mock(Principal.class);
-
- context.checking(new Expectations() {
- {
- allowing(requestData).getResourceResolver();
- will(returnValue(resourceResolver));
- allowing(resourceResolver).adaptTo(Principal.class);
- will(returnValue(principal));
-
allowing(requestData).isDisableCheckCompliantGetUserPrincipal();
- will(returnValue(true));
- allowing(requestData).logNonCompliantGetUserPrincipalWarning();
- }
- });
+ final HttpServletRequest servletRequest =
Mockito.mock(HttpServletRequest.class);
+ Mockito.when(servletRequest.getServletPath()).thenReturn("/path");
+ Mockito.when(servletRequest.getPathInfo()).thenReturn("/path");
+ Mockito.when(servletRequest.getRemoteUser()).thenReturn(null);
+
+ final RequestData requestData = Mockito.mock(RequestData.class);
+ final ResourceResolver resourceResolver =
Mockito.mock(ResourceResolver.class);
+ final Principal principal = Mockito.mock(Principal.class);
+
Mockito.when(requestData.getResourceResolver()).thenReturn(resourceResolver);
+
Mockito.when(resourceResolver.adaptTo(Principal.class)).thenReturn(principal);
+
Mockito.when(requestData.isDisableCheckCompliantGetUserPrincipal()).thenReturn(true);
slingHttpServletRequestImpl = new
SlingJakartaHttpServletRequestImpl(requestData, servletRequest);
assertSame(principal, slingHttpServletRequestImpl.getUserPrincipal());
+ Mockito.verify(servletRequest).getServletPath();
}
@Test
public void getUserPrincipal_testWithPrincipal() {
- final HttpServletRequest servletRequest =
context.mock(HttpServletRequest.class);
-
- context.checking(new Expectations() {
- {
- oneOf(servletRequest).getServletPath();
- will(returnValue("/path"));
- allowing(servletRequest).getPathInfo();
- will(returnValue("/path"));
- allowing(servletRequest).getRemoteUser();
- will(returnValue("remoteUser"));
- }
- });
-
- final RequestData requestData = context.mock(RequestData.class,
"requestData");
- final ResourceResolver resourceResolver =
context.mock(ResourceResolver.class);
- final Principal principal = context.mock(Principal.class);
-
- context.checking(new Expectations() {
- {
- allowing(requestData).getResourceResolver();
- will(returnValue(resourceResolver));
- allowing(resourceResolver).adaptTo(Principal.class);
- will(returnValue(principal));
-
allowing(requestData).isDisableCheckCompliantGetUserPrincipal();
- will(returnValue(false));
- }
- });
+ final HttpServletRequest servletRequest =
Mockito.mock(HttpServletRequest.class);
+ Mockito.when(servletRequest.getServletPath()).thenReturn("/path");
+ Mockito.when(servletRequest.getPathInfo()).thenReturn("/path");
+ Mockito.when(servletRequest.getRemoteUser()).thenReturn("remoteUser");
+
+ final RequestData requestData = Mockito.mock(RequestData.class);
+ final ResourceResolver resourceResolver =
Mockito.mock(ResourceResolver.class);
+ final Principal principal = Mockito.mock(Principal.class);
+
Mockito.when(requestData.getResourceResolver()).thenReturn(resourceResolver);
+
Mockito.when(resourceResolver.adaptTo(Principal.class)).thenReturn(principal);
+
Mockito.when(requestData.isDisableCheckCompliantGetUserPrincipal()).thenReturn(false);
slingHttpServletRequestImpl = new
SlingJakartaHttpServletRequestImpl(requestData, servletRequest);
assertEquals(principal,
slingHttpServletRequestImpl.getUserPrincipal());
+ Mockito.verify(servletRequest).getServletPath();
}
@Test
public void getUserPrincipal_testWithPrincipal_nonspeccompliant() {
- final HttpServletRequest servletRequest =
context.mock(HttpServletRequest.class);
-
- context.checking(new Expectations() {
- {
- oneOf(servletRequest).getServletPath();
- will(returnValue("/path"));
- allowing(servletRequest).getPathInfo();
- will(returnValue("/path"));
- allowing(servletRequest).getRemoteUser();
- will(returnValue("remoteUser"));
- }
- });
-
- final RequestData requestData = context.mock(RequestData.class,
"requestData");
- final ResourceResolver resourceResolver =
context.mock(ResourceResolver.class);
- final Principal principal = context.mock(Principal.class);
-
- context.checking(new Expectations() {
- {
- allowing(requestData).getResourceResolver();
- will(returnValue(resourceResolver));
- allowing(resourceResolver).adaptTo(Principal.class);
- will(returnValue(principal));
-
allowing(requestData).isDisableCheckCompliantGetUserPrincipal();
- will(returnValue(true));
- }
- });
+ final HttpServletRequest servletRequest =
Mockito.mock(HttpServletRequest.class);
+ Mockito.when(servletRequest.getServletPath()).thenReturn("/path");
+ Mockito.when(servletRequest.getPathInfo()).thenReturn("/path");
+ Mockito.when(servletRequest.getRemoteUser()).thenReturn("remoteUser");
+
+ final RequestData requestData = Mockito.mock(RequestData.class);
+ final ResourceResolver resourceResolver =
Mockito.mock(ResourceResolver.class);
+ final Principal principal = Mockito.mock(Principal.class);
+
Mockito.when(requestData.getResourceResolver()).thenReturn(resourceResolver);
+
Mockito.when(resourceResolver.adaptTo(Principal.class)).thenReturn(principal);
+
Mockito.when(requestData.isDisableCheckCompliantGetUserPrincipal()).thenReturn(true);
slingHttpServletRequestImpl = new
SlingJakartaHttpServletRequestImpl(requestData, servletRequest);
assertEquals(principal,
slingHttpServletRequestImpl.getUserPrincipal());
+ Mockito.verify(servletRequest).getServletPath();
}
private void assertEmptyEnumerator(final Enumeration<String> e) {
diff --git
a/src/test/java/org/apache/sling/engine/impl/filter/AbstractFilterTest.java
b/src/test/java/org/apache/sling/engine/impl/filter/AbstractFilterTest.java
index abe0cef..5f9229f 100644
--- a/src/test/java/org/apache/sling/engine/impl/filter/AbstractFilterTest.java
+++ b/src/test/java/org/apache/sling/engine/impl/filter/AbstractFilterTest.java
@@ -25,16 +25,12 @@ import jakarta.servlet.Filter;
import org.apache.sling.api.SlingJakartaHttpServletRequest;
import org.apache.sling.api.request.RequestPathInfo;
import org.apache.sling.api.request.builder.Builders;
-import org.jmock.Expectations;
-import org.jmock.Mockery;
-import org.jmock.integration.junit4.JUnit4Mockery;
+import org.mockito.Mockito;
import org.osgi.framework.Bundle;
import org.osgi.framework.ServiceReference;
public abstract class AbstractFilterTest {
- protected final Mockery context = new JUnit4Mockery();
-
protected ServiceReference<Filter> mockService(Object... map) {
final Dictionary<String, Object> props = new Hashtable<>();
@@ -87,70 +83,37 @@ public abstract class AbstractFilterTest {
final String[] selectors,
final String method,
final String suffix) {
- final RequestPathInfo info = context.mock(RequestPathInfo.class, "info
" + path + extension + method + suffix);
- context.checking(new Expectations() {
- {
- allowing(info).getExtension();
- will(returnValue(extension));
- allowing(info).getSuffix();
- will(returnValue(suffix));
- allowing(info).getSelectors();
- will(returnValue(selectors == null ? new String[0] :
selectors));
- allowing(info).getResourcePath();
- will(returnValue(path));
- }
- });
+ final RequestPathInfo info = Mockito.mock(RequestPathInfo.class, "info
" + path + extension + method + suffix);
+ Mockito.when(info.getExtension()).thenReturn(extension);
+ Mockito.when(info.getSuffix()).thenReturn(suffix);
+ Mockito.when(info.getSelectors()).thenReturn(selectors == null ? new
String[0] : selectors);
+ Mockito.when(info.getResourcePath()).thenReturn(path);
final SlingJakartaHttpServletRequest req =
- context.mock(SlingJakartaHttpServletRequest.class, "req " +
path + extension + method + suffix);
- context.checking(new Expectations() {
- {
- allowing(req).getRequestProgressTracker();
- will(returnValue(Builders.newRequestProgressTracker()));
- allowing(req).getRequestPathInfo();
- will(returnValue(info));
- allowing(req).getMethod();
- will(returnValue(method));
- allowing(req).getPathInfo();
- will(returnValue(path));
- allowing(req).getServletPath();
- will(returnValue(path));
- allowing(req).getAttribute(with(any(String.class)));
- will(returnValue(new Object()));
- }
- });
+ Mockito.mock(SlingJakartaHttpServletRequest.class, "req " +
path + extension + method + suffix);
+
Mockito.when(req.getRequestProgressTracker()).thenReturn(Builders.newRequestProgressTracker());
+ Mockito.when(req.getRequestPathInfo()).thenReturn(info);
+ Mockito.when(req.getMethod()).thenReturn(method);
+ Mockito.when(req.getPathInfo()).thenReturn(path);
+ Mockito.when(req.getServletPath()).thenReturn(path);
+ Mockito.when(req.getAttribute(Mockito.anyString())).thenReturn(new
Object());
return req;
}
protected SlingJakartaHttpServletRequest mockRequest(
final String resourcePath, final String requestPath, final String
extension) {
final RequestPathInfo info =
- context.mock(RequestPathInfo.class, "info " + resourcePath +
requestPath + extension);
- context.checking(new Expectations() {
- {
- allowing(info).getExtension();
- will(returnValue(extension));
- allowing(info).getSuffix();
- will(returnValue(null));
- allowing(info).getSelectors();
- will(returnValue(new String[0]));
- allowing(info).getResourcePath();
- will(returnValue(resourcePath));
- }
- });
+ Mockito.mock(RequestPathInfo.class, "info " + resourcePath +
requestPath + extension);
+ Mockito.when(info.getExtension()).thenReturn(extension);
+ Mockito.when(info.getSuffix()).thenReturn(null);
+ Mockito.when(info.getSelectors()).thenReturn(new String[0]);
+ Mockito.when(info.getResourcePath()).thenReturn(resourcePath);
final SlingJakartaHttpServletRequest req =
- context.mock(SlingJakartaHttpServletRequest.class, "req " +
resourcePath + requestPath + extension);
- context.checking(new Expectations() {
- {
- allowing(req).getRequestPathInfo();
- will(returnValue(info));
- allowing(req).getMethod();
- will(returnValue(null));
- allowing(req).getPathInfo();
- will(returnValue(requestPath));
- }
- });
+ Mockito.mock(SlingJakartaHttpServletRequest.class, "req " +
resourcePath + requestPath + extension);
+ Mockito.when(req.getRequestPathInfo()).thenReturn(info);
+ Mockito.when(req.getMethod()).thenReturn(null);
+ Mockito.when(req.getPathInfo()).thenReturn(requestPath);
return req;
}
diff --git
a/src/test/java/org/apache/sling/engine/impl/filter/AbstractSlingFilterChainTest.java
b/src/test/java/org/apache/sling/engine/impl/filter/AbstractSlingFilterChainTest.java
index 7c39565..84d68dc 100644
---
a/src/test/java/org/apache/sling/engine/impl/filter/AbstractSlingFilterChainTest.java
+++
b/src/test/java/org/apache/sling/engine/impl/filter/AbstractSlingFilterChainTest.java
@@ -34,6 +34,7 @@ import
org.apache.sling.engine.impl.SlingJakartaHttpServletRequestImpl;
import org.apache.sling.engine.impl.SlingRequestProcessorImpl;
import org.apache.sling.engine.impl.request.RequestData;
import org.junit.Test;
+import org.mockito.Mockito;
import static org.junit.Assert.assertTrue;
@@ -65,11 +66,11 @@ public class AbstractSlingFilterChainTest extends
AbstractFilterTest {
};
HttpServletRequest httpReq = whateverRequest();
final RequestData requestData = new RequestData(
- new SlingRequestProcessorImpl(), httpReq,
context.mock(HttpServletResponse.class), false, false, true);
+ new SlingRequestProcessorImpl(), httpReq,
Mockito.mock(HttpServletResponse.class), false, false, true);
final SlingJakartaHttpServletRequestImpl req = new
SlingJakartaHttpServletRequestImpl(requestData, httpReq);
boolean illegalStateCaught = false;
try {
- chain.doFilter(req,
context.mock(SlingJakartaHttpServletResponse.class));
+ chain.doFilter(req,
Mockito.mock(SlingJakartaHttpServletResponse.class));
} catch (IllegalStateException e) {
illegalStateCaught = true;
}
diff --git
a/src/test/java/org/apache/sling/engine/impl/filter/SlingFilterChainHelperTest.java
b/src/test/java/org/apache/sling/engine/impl/filter/SlingFilterChainHelperTest.java
index 738e6cb..8b2b450 100644
---
a/src/test/java/org/apache/sling/engine/impl/filter/SlingFilterChainHelperTest.java
+++
b/src/test/java/org/apache/sling/engine/impl/filter/SlingFilterChainHelperTest.java
@@ -19,9 +19,8 @@
package org.apache.sling.engine.impl.filter;
import jakarta.servlet.Filter;
-import org.jmock.Mockery;
-import org.jmock.integration.junit4.JUnit4Mockery;
import org.junit.Test;
+import org.mockito.Mockito;
import static org.junit.Assert.assertEquals;
@@ -30,17 +29,15 @@ import static org.junit.Assert.assertEquals;
*/
public class SlingFilterChainHelperTest {
- private final Mockery context = new JUnit4Mockery();
-
@Test
public void testOrdering() {
final SlingFilterChainHelper chain = new SlingFilterChainHelper();
- chain.addFilter(context.mock(Filter.class, "A"), null, null, 1L, 100,
"1:100", null);
- chain.addFilter(context.mock(Filter.class, "B"), null, null, 2L, 100,
"2:100", null);
- chain.addFilter(context.mock(Filter.class, "C"), null, null, 3L, -100,
"3:-100", null);
- chain.addFilter(context.mock(Filter.class, "D"), null, null, 4L,
-1000, "4:-1000", null);
- chain.addFilter(context.mock(Filter.class, "E"), null, null, 5L, 1000,
"5:1000", null);
+ chain.addFilter(Mockito.mock(Filter.class, "A"), null, null, 1L, 100,
"1:100", null);
+ chain.addFilter(Mockito.mock(Filter.class, "B"), null, null, 2L, 100,
"2:100", null);
+ chain.addFilter(Mockito.mock(Filter.class, "C"), null, null, 3L, -100,
"3:-100", null);
+ chain.addFilter(Mockito.mock(Filter.class, "D"), null, null, 4L,
-1000, "4:-1000", null);
+ chain.addFilter(Mockito.mock(Filter.class, "E"), null, null, 5L, 1000,
"5:1000", null);
final FilterHandle[] entries = chain.getFilters();
assertEquals(5, entries.length);
diff --git
a/src/test/java/org/apache/sling/engine/impl/helper/ExternalServletContextWrapperTest.java
b/src/test/java/org/apache/sling/engine/impl/helper/ExternalServletContextWrapperTest.java
index 3257339..030f3d0 100644
---
a/src/test/java/org/apache/sling/engine/impl/helper/ExternalServletContextWrapperTest.java
+++
b/src/test/java/org/apache/sling/engine/impl/helper/ExternalServletContextWrapperTest.java
@@ -35,43 +35,28 @@ import
org.apache.sling.engine.impl.SlingJakartaHttpServletResponseImpl;
import org.apache.sling.engine.impl.SlingRequestProcessorImpl;
import
org.apache.sling.engine.impl.helper.ExternalServletContextWrapper.RequestDispatcherWrapper;
import org.apache.sling.engine.impl.request.RequestData;
-import org.jmock.Expectations;
-import org.jmock.Mockery;
-import org.jmock.imposters.ByteBuddyClassImposteriser;
-import org.jmock.integration.junit4.JUnit4Mockery;
-import org.junit.Before;
import org.junit.Test;
+import org.mockito.Mockito;
import static org.junit.Assert.*;
public class ExternalServletContextWrapperTest {
- Mockery context = new JUnit4Mockery();
-
- @Before
- public void setup() {
- context.setImposteriser(ByteBuddyClassImposteriser.INSTANCE);
- }
-
/**
* Tests that the RequestDispatcher is wrapped.
*/
@Test
public void testGetRequestDispatcher() {
- final RequestDispatcher rd = context.mock(RequestDispatcher.class);
- final ServletContext ctx = context.mock(ServletContext.class);
- context.checking(new Expectations() {
- {
- oneOf(ctx).getRequestDispatcher("foo.jsp");
- will(returnValue(rd));
- }
- });
+ final RequestDispatcher rd = Mockito.mock(RequestDispatcher.class);
+ final ServletContext ctx = Mockito.mock(ServletContext.class);
+ Mockito.when(ctx.getRequestDispatcher("foo.jsp")).thenReturn(rd);
ExternalServletContextWrapper wrapper = new
ExternalServletContextWrapper(ctx);
RequestDispatcher dispatcher = wrapper.getRequestDispatcher("foo.jsp");
assertTrue(dispatcher instanceof RequestDispatcherWrapper);
assertEquals(rd, ((RequestDispatcherWrapper)
dispatcher).getDelegate());
+ Mockito.verify(ctx).getRequestDispatcher("foo.jsp");
}
/**
@@ -79,7 +64,7 @@ public class ExternalServletContextWrapperTest {
*/
@Test
public void testUnwrappingRegularRequest() {
- final ServletRequest req = context.mock(ServletRequest.class);
+ final ServletRequest req = Mockito.mock(ServletRequest.class);
ServletRequest unwrapped =
ExternalServletContextWrapper.RequestDispatcherWrapper.unwrapServletRequest(req);
@@ -91,7 +76,7 @@ public class ExternalServletContextWrapperTest {
*/
@Test
public void testUnwrappingWrappedRequest() {
- final ServletRequest req = context.mock(ServletRequest.class);
+ final ServletRequest req = Mockito.mock(ServletRequest.class);
final ServletRequestWrapper wrapper = new ServletRequestWrapper(req);
ServletRequest unwrapped =
ExternalServletContextWrapper.RequestDispatcherWrapper.unwrapServletRequest(wrapper);
@@ -101,7 +86,7 @@ public class ExternalServletContextWrapperTest {
@Test
public void testUnwrappingDoubleWrappedRequest() {
- final ServletRequest req = context.mock(ServletRequest.class);
+ final ServletRequest req = Mockito.mock(ServletRequest.class);
final ServletRequestWrapper wrapper = new ServletRequestWrapper(req);
final ServletRequestWrapper wrapper2 = new
ServletRequestWrapper(wrapper);
@@ -117,16 +102,9 @@ public class ExternalServletContextWrapperTest {
*/
@Test
public void testUnwrappingSlingRequest() {
- final HttpServletRequest req = context.mock(HttpServletRequest.class);
-
- context.checking(new Expectations() {
- {
- allowing(req).getServletPath();
- will(returnValue("/"));
- allowing(req).getPathInfo();
- will(returnValue("/test"));
- }
- });
+ final HttpServletRequest req = Mockito.mock(HttpServletRequest.class);
+ Mockito.when(req.getServletPath()).thenReturn("/");
+ Mockito.when(req.getPathInfo()).thenReturn("/test");
final HttpServletRequestWrapper wrapper = new
HttpServletRequestWrapper(req);
final HttpServletRequestWrapper wrapper2 = new
HttpServletRequestWrapper(wrapper);
@@ -144,16 +122,9 @@ public class ExternalServletContextWrapperTest {
*/
@Test
public void testUnwrappingWrappedSlingRequest() {
- final HttpServletRequest req = context.mock(HttpServletRequest.class);
-
- context.checking(new Expectations() {
- {
- allowing(req).getServletPath();
- will(returnValue("/"));
- allowing(req).getPathInfo();
- will(returnValue("/test"));
- }
- });
+ final HttpServletRequest req = Mockito.mock(HttpServletRequest.class);
+ Mockito.when(req.getServletPath()).thenReturn("/");
+ Mockito.when(req.getPathInfo()).thenReturn("/test");
final HttpServletRequestWrapper wrapper = new
HttpServletRequestWrapper(req);
final HttpServletRequestWrapper wrapper2 = new
HttpServletRequestWrapper(wrapper);
@@ -171,7 +142,7 @@ public class ExternalServletContextWrapperTest {
*/
@Test
public void testUnwrappingRegularResponse() {
- final ServletResponse req = context.mock(ServletResponse.class);
+ final ServletResponse req = Mockito.mock(ServletResponse.class);
ServletResponse unwrapped =
ExternalServletContextWrapper.RequestDispatcherWrapper.unwrapServletResponse(req);
@@ -183,7 +154,7 @@ public class ExternalServletContextWrapperTest {
*/
@Test
public void testUnwrappingWrappedResponse() {
- final ServletResponse resp = context.mock(ServletResponse.class);
+ final ServletResponse resp = Mockito.mock(ServletResponse.class);
final ServletResponseWrapper wrapper = new
ServletResponseWrapper(resp);
ServletResponse unwrapped =
@@ -194,7 +165,7 @@ public class ExternalServletContextWrapperTest {
@Test
public void testUnwrappingDoubleWrappedResponse() {
- final ServletResponse resp = context.mock(ServletResponse.class);
+ final ServletResponse resp = Mockito.mock(ServletResponse.class);
final ServletResponseWrapper wrapper = new
ServletResponseWrapper(resp);
final ServletResponseWrapper wrapper2 = new
ServletResponseWrapper(wrapper);
@@ -210,19 +181,13 @@ public class ExternalServletContextWrapperTest {
*/
@Test
public void testUnwrappingSlingResponse() {
- final HttpServletResponse resp =
context.mock(HttpServletResponse.class);
+ final HttpServletResponse resp =
Mockito.mock(HttpServletResponse.class);
final HttpServletResponseWrapper wrapper = new
HttpServletResponseWrapper(resp);
final HttpServletResponseWrapper wrapper2 = new
HttpServletResponseWrapper(wrapper);
- final RequestData rd = this.context.mock(RequestData.class);
- final SlingRequestProcessorImpl processor =
this.context.mock(SlingRequestProcessorImpl.class);
- context.checking(new Expectations() {
- {
- allowing(rd).getSlingRequestProcessor();
- will(returnValue(processor));
- allowing(processor).getAdditionalResponseHeaders();
- will(returnValue(Collections.emptyList()));
- }
- });
+ final RequestData rd = Mockito.mock(RequestData.class);
+ final SlingRequestProcessorImpl processor =
Mockito.mock(SlingRequestProcessorImpl.class);
+ Mockito.when(rd.getSlingRequestProcessor()).thenReturn(processor);
+
Mockito.when(processor.getAdditionalResponseHeaders()).thenReturn(Collections.emptyList());
final SlingJakartaHttpServletResponseImpl slingResponse = new
SlingJakartaHttpServletResponseImpl(rd, wrapper2);
@@ -238,19 +203,13 @@ public class ExternalServletContextWrapperTest {
*/
@Test
public void testUnwrappingWrappedSlingResponse() {
- final HttpServletResponse resp =
context.mock(HttpServletResponse.class);
+ final HttpServletResponse resp =
Mockito.mock(HttpServletResponse.class);
final HttpServletResponseWrapper wrapper = new
HttpServletResponseWrapper(resp);
final HttpServletResponseWrapper wrapper2 = new
HttpServletResponseWrapper(wrapper);
- final RequestData rd = this.context.mock(RequestData.class);
- final SlingRequestProcessorImpl processor =
this.context.mock(SlingRequestProcessorImpl.class);
- context.checking(new Expectations() {
- {
- allowing(rd).getSlingRequestProcessor();
- will(returnValue(processor));
- allowing(processor).getAdditionalResponseHeaders();
- will(returnValue(Collections.emptyList()));
- }
- });
+ final RequestData rd = Mockito.mock(RequestData.class);
+ final SlingRequestProcessorImpl processor =
Mockito.mock(SlingRequestProcessorImpl.class);
+ Mockito.when(rd.getSlingRequestProcessor()).thenReturn(processor);
+
Mockito.when(processor.getAdditionalResponseHeaders()).thenReturn(Collections.emptyList());
final SlingJakartaHttpServletResponseImpl slingResponse = new
SlingJakartaHttpServletResponseImpl(rd, wrapper2);
final HttpServletResponseWrapper slingWrapper = new
HttpServletResponseWrapper(slingResponse);
diff --git
a/src/test/java/org/apache/sling/engine/impl/log/ClientAbortExceptionTest.java
b/src/test/java/org/apache/sling/engine/impl/log/ClientAbortExceptionTest.java
index a6ac361..b1944d9 100644
---
a/src/test/java/org/apache/sling/engine/impl/log/ClientAbortExceptionTest.java
+++
b/src/test/java/org/apache/sling/engine/impl/log/ClientAbortExceptionTest.java
@@ -24,21 +24,17 @@ import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.WriteListener;
import jakarta.servlet.http.HttpServletResponse;
import org.apache.sling.engine.impl.helper.ClientAbortException;
-import org.jmock.Expectations;
-import org.jmock.Mockery;
import org.junit.Before;
import org.junit.Test;
+import org.mockito.Mockito;
/** Verify that RequestLoggerResponse wraps IOException in
ClientAbortException */
public class ClientAbortExceptionTest {
- private Mockery context;
private RequestLoggerResponse r;
@Before
public void setup() throws IOException {
- context = new Mockery();
-
final ServletOutputStream sos = new ServletOutputStream() {
@Override
public void write(int b) throws IOException {
@@ -63,13 +59,8 @@ public class ClientAbortExceptionTest {
@Override
public void setWriteListener(WriteListener writeListener) {}
};
- final HttpServletResponse raw =
context.mock(HttpServletResponse.class);
- context.checking(new Expectations() {
- {
- allowing(raw).getOutputStream();
- will(returnValue(sos));
- }
- });
+ final HttpServletResponse raw =
Mockito.mock(HttpServletResponse.class);
+ Mockito.when(raw.getOutputStream()).thenReturn(sos);
r = new RequestLoggerResponse(null, raw);
}
diff --git
a/src/test/java/org/apache/sling/engine/impl/request/InitResourceTest.java
b/src/test/java/org/apache/sling/engine/impl/request/InitResourceTest.java
index 86f0acb..171db88 100644
--- a/src/test/java/org/apache/sling/engine/impl/request/InitResourceTest.java
+++ b/src/test/java/org/apache/sling/engine/impl/request/InitResourceTest.java
@@ -24,17 +24,15 @@ import java.util.Collections;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
-import org.apache.sling.api.request.RequestProgressTracker;
+import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.engine.impl.SlingRequestProcessorImpl;
-import org.jmock.Expectations;
-import org.jmock.Mockery;
-import org.jmock.imposters.ByteBuddyClassImposteriser;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
+import org.mockito.Mockito;
/**
* Verifies {@link RequestData#initResource(ResourceResolver)}, in particular
the fallback
@@ -64,13 +62,11 @@ import org.junit.runners.Parameterized.Parameters;
@RunWith(Parameterized.class)
public class InitResourceTest {
- private Mockery context;
private RequestData requestData;
private HttpServletRequest req;
private HttpServletResponse resp;
private ResourceResolver resourceResolver;
- private final String description;
private final String rawRequestURL;
private final String containerPathInfo;
private final String expectedResolvedPath;
@@ -256,13 +252,12 @@ public class InitResourceTest {
}
public InitResourceTest(
- String description,
+ String description, // just a test description, not used
String rawRequestURL,
String containerPathInfo,
String expectedResolvedPath,
String contextPath,
String servletPath) {
- this.description = description;
this.rawRequestURL = rawRequestURL;
this.containerPathInfo = containerPathInfo;
this.expectedResolvedPath = expectedResolvedPath;
@@ -272,59 +267,22 @@ public class InitResourceTest {
@Before
public void setup() throws Exception {
- context = new Mockery() {
- {
- setImposteriser(ByteBuddyClassImposteriser.INSTANCE);
- }
- };
-
- req = context.mock(HttpServletRequest.class);
- resp = context.mock(HttpServletResponse.class);
- resourceResolver = context.mock(ResourceResolver.class);
- final SlingRequestProcessorImpl processor =
context.mock(SlingRequestProcessorImpl.class);
-
- context.checking(new Expectations() {
- {
- allowing(req).getRequestURL();
- will(returnValue(new StringBuffer(rawRequestURL)));
-
- allowing(req).getRequestURI();
-
- allowing(req).getPathInfo();
- will(returnValue(containerPathInfo));
-
- allowing(req).getContextPath();
- will(returnValue(contextPath));
+ req = Mockito.mock(HttpServletRequest.class);
+ resp = Mockito.mock(HttpServletResponse.class);
+ resourceResolver = Mockito.mock(ResourceResolver.class);
+ final SlingRequestProcessorImpl processor =
Mockito.mock(SlingRequestProcessorImpl.class);
+ final Resource resource = Mockito.mock(Resource.class);
- allowing(req).getServletPath();
- will(returnValue(servletPath));
-
- allowing(req).getMethod();
- will(returnValue("GET"));
-
-
allowing(req).getAttribute(RequestData.REQUEST_RESOURCE_PATH_ATTR);
- will(returnValue(null));
- allowing(req)
-
.setAttribute(with(equal(RequestData.REQUEST_RESOURCE_PATH_ATTR)),
with(any(Object.class)));
-
-
allowing(req).getAttribute(RequestProgressTracker.class.getName());
- will(returnValue(null));
-
- // Verify that the ResourceResolver is called with the
expected (re-derived or
- // passed-through) path
- if (expectedResolvedPath == null) {
-
allowing(resourceResolver).resolve(with(any(HttpServletRequest.class)),
with(aNull(String.class)));
- } else {
- allowing(resourceResolver)
- .resolve(with(any(HttpServletRequest.class)),
with(equal(expectedResolvedPath)));
- }
-
- allowing(processor).getMaxCallCounter();
- will(returnValue(2));
- allowing(processor).getAdditionalResponseHeaders();
- will(returnValue(Collections.emptyList()));
- }
- });
+ Mockito.when(req.getRequestURL()).thenReturn(new
StringBuffer(rawRequestURL));
+ Mockito.when(req.getPathInfo()).thenReturn(containerPathInfo);
+ Mockito.when(req.getContextPath()).thenReturn(contextPath);
+ Mockito.when(req.getServletPath()).thenReturn(servletPath);
+ Mockito.when(req.getMethod()).thenReturn("GET");
+ Mockito.when(processor.getMaxCallCounter()).thenReturn(2);
+
Mockito.when(processor.getAdditionalResponseHeaders()).thenReturn(Collections.emptyList());
+
Mockito.when(resourceResolver.resolve(Mockito.any(HttpServletRequest.class),
Mockito.eq(expectedResolvedPath)))
+ .thenReturn(resource);
+ Mockito.when(resource.getPath()).thenReturn("/");
requestData = new RequestData(processor, req, resp, false, false,
true);
}
@@ -332,5 +290,7 @@ public class InitResourceTest {
@Test
public void resolverPathMatches() {
requestData.initResource(resourceResolver);
+ Mockito.verify(resourceResolver)
+ .resolve(Mockito.any(HttpServletRequest.class),
Mockito.eq(expectedResolvedPath));
}
}
diff --git
a/src/test/java/org/apache/sling/engine/impl/request/RequestDataTest.java
b/src/test/java/org/apache/sling/engine/impl/request/RequestDataTest.java
index ff76938..de33af6 100644
--- a/src/test/java/org/apache/sling/engine/impl/request/RequestDataTest.java
+++ b/src/test/java/org/apache/sling/engine/impl/request/RequestDataTest.java
@@ -24,28 +24,23 @@ import java.util.Collections;
import jakarta.servlet.Servlet;
import jakarta.servlet.ServletConfig;
import jakarta.servlet.ServletException;
-import jakarta.servlet.ServletRequest;
-import jakarta.servlet.ServletResponse;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.apache.sling.api.SlingJakartaHttpServletRequest;
import org.apache.sling.api.SlingJakartaHttpServletResponse;
-import org.apache.sling.api.request.RequestProgressTracker;
+import org.apache.sling.api.request.RequestPathInfo;
import org.apache.sling.api.request.TooManyCallsException;
import org.apache.sling.engine.impl.SlingJakartaHttpServletRequestImpl;
import org.apache.sling.engine.impl.SlingJakartaHttpServletResponseImpl;
import org.apache.sling.engine.impl.SlingRequestProcessorImpl;
-import org.jmock.Expectations;
-import org.jmock.Mockery;
-import org.jmock.imposters.ByteBuddyClassImposteriser;
import org.junit.Before;
import org.junit.Test;
+import org.mockito.Mockito;
import static org.junit.Assert.*;
public class RequestDataTest {
- private Mockery context;
private RequestData requestData;
private HttpServletRequest req;
private HttpServletResponse resp;
@@ -54,55 +49,25 @@ public class RequestDataTest {
@Before
public void setup() throws ServletException, IOException {
- context = new Mockery() {
- {
- setImposteriser(ByteBuddyClassImposteriser.INSTANCE);
- }
- };
-
- req = context.mock(HttpServletRequest.class);
- resp = context.mock(HttpServletResponse.class);
-
- final ContentData contentData = context.mock(ContentData.class);
- final Servlet servlet = context.mock(Servlet.class);
- final ServletConfig servletConfig = context.mock(ServletConfig.class);
- final SlingRequestProcessorImpl processor =
context.mock(SlingRequestProcessorImpl.class);
- context.checking(new Expectations() {
- {
- allowing(req).getServletPath();
- will(returnValue("/"));
-
- allowing(req).getPathInfo();
- will(returnValue(""));
-
- allowing(req).getMethod();
- will(returnValue("GET"));
-
- allowing(req).setAttribute(with(any(String.class)),
with(any(Object.class)));
- allowing(req).setAttribute(with(any(String.class)),
with(aNull(Object.class)));
-
- allowing(contentData).getServlet();
- will(returnValue(servlet));
-
- allowing(servlet).getServletConfig();
- will(returnValue(servletConfig));
-
- allowing(contentData).getRequestPathInfo();
-
- allowing(servlet).service(with(any(ServletRequest.class)),
with(any(ServletResponse.class)));
-
- allowing(servletConfig).getServletName();
- will(returnValue("SERVLET_NAME"));
-
-
allowing(req).getAttribute(RequestProgressTracker.class.getName());
- will(returnValue(null));
-
- allowing(processor).getMaxCallCounter();
- will(returnValue(2));
- allowing(processor).getAdditionalResponseHeaders();
- will(returnValue(Collections.emptyList()));
- }
- });
+ req = Mockito.mock(HttpServletRequest.class);
+ resp = Mockito.mock(HttpServletResponse.class);
+
+ final ContentData contentData = Mockito.mock(ContentData.class);
+ final RequestPathInfo requestPathInfo =
Mockito.mock(RequestPathInfo.class);
+ final Servlet servlet = Mockito.mock(Servlet.class);
+ final ServletConfig servletConfig = Mockito.mock(ServletConfig.class);
+ final SlingRequestProcessorImpl processor =
Mockito.mock(SlingRequestProcessorImpl.class);
+ Mockito.when(req.getServletPath()).thenReturn("/");
+ Mockito.when(req.getPathInfo()).thenReturn("");
+ Mockito.when(req.getMethod()).thenReturn("GET");
+
Mockito.when(contentData.getRequestPathInfo()).thenReturn(requestPathInfo);
+ Mockito.when(requestPathInfo.getResourcePath()).thenReturn("/");
+ Mockito.when(requestPathInfo.getSelectors()).thenReturn(new String[0]);
+ Mockito.when(contentData.getServlet()).thenReturn(servlet);
+ Mockito.when(servlet.getServletConfig()).thenReturn(servletConfig);
+
Mockito.when(servletConfig.getServletName()).thenReturn("SERVLET_NAME");
+ Mockito.when(processor.getMaxCallCounter()).thenReturn(2);
+
Mockito.when(processor.getAdditionalResponseHeaders()).thenReturn(Collections.emptyList());
requestData = new RequestData(processor, req, resp, false, false,
true) {
@Override
@@ -129,23 +94,12 @@ public class RequestDataTest {
@Test
public void testTooManyCallsDefault() throws Exception {
- context.checking(new Expectations() {
- {
- allowing(req).getAttribute(with(any(String.class)));
- will(returnValue(null));
- }
- });
assertTooManyCallsException(3);
}
@Test
public void testTooManyCallsOverride() throws Exception {
- context.checking(new Expectations() {
- {
- allowing(req).getAttribute(with(any(String.class)));
- will(returnValue(1));
- }
- });
+ Mockito.when(req.getAttribute(Mockito.anyString())).thenReturn(1);
assertTooManyCallsException(2);
}
