The Unified and Autonomous Development Platform
fix: Harden internal LFS transfers and uploads
Robin Shen27216d8cdccd
diff --git a/server-core/src/main/java/io/onedev/server/cluster/ClusterResource.java b/server-core/src/main/java/io/onedev/server/cluster/ClusterResource.javaindex 5b7de0463a..80bf665260 100644--- a/server-core/src/main/java/io/onedev/server/cluster/ClusterResource.java+++ b/server-core/src/main/java/io/onedev/server/cluster/ClusterResource.java@@ -381,8 +381,8 @@ public class ClusterResource {if (!SecurityUtils.isSystem())throw new UnauthorizedException("This api can only be accessed via cluster credential");- try (input; OutputStream os = new LfsObject(projectId, objectId).getOutputStream()) {- IOUtils.copy(input, os, BUFFER_SIZE);+ try (input) {+ new LfsObject(projectId, objectId).upload(input);} catch (IOException e) {throw new RuntimeException(e);}diff --git a/server-core/src/main/java/io/onedev/server/git/GitLfsFilter.java b/server-core/src/main/java/io/onedev/server/git/GitLfsFilter.javaindex 886498680c..8c3304cac7 100644--- a/server-core/src/main/java/io/onedev/server/git/GitLfsFilter.java+++ b/server-core/src/main/java/io/onedev/server/git/GitLfsFilter.java@@ -1,6 +1,5 @@package io.onedev.server.git;-import static com.google.common.hash.Hashing.sha256;import static io.onedev.k8shelper.KubernetesHelper.BEARER;import static io.onedev.server.model.Project.decodeFullRepoNameAsPath;import static io.onedev.server.util.CollectionUtils.newHashMap;@@ -12,6 +11,7 @@ import static jakarta.servlet.http.HttpServletResponse.SC_INTERNAL_SERVER_ERROR;import static jakarta.servlet.http.HttpServletResponse.SC_NOT_ACCEPTABLE;import static jakarta.servlet.http.HttpServletResponse.SC_NOT_FOUND;import static jakarta.servlet.http.HttpServletResponse.SC_NOT_IMPLEMENTED;+import static jakarta.servlet.http.HttpServletResponse.SC_REQUEST_ENTITY_TOO_LARGE;import static jakarta.servlet.http.HttpServletResponse.SC_UNAUTHORIZED;import static jakarta.ws.rs.core.HttpHeaders.AUTHORIZATION;import static jakarta.ws.rs.core.MediaType.APPLICATION_OCTET_STREAM;@@ -28,7 +28,6 @@ import java.util.HashMap;import java.util.List;import java.util.Map;import java.util.Set;-import java.util.concurrent.atomic.AtomicReference;import java.util.function.BooleanSupplier;import jakarta.inject.Inject;@@ -49,7 +48,6 @@ import jakarta.ws.rs.client.WebTarget;import jakarta.ws.rs.core.Response;import jakarta.ws.rs.core.StreamingOutput;-import org.apache.commons.codec.binary.Hex;import org.apache.commons.lang3.StringUtils;import io.onedev.server.persistence.dao.Restrictions;import org.jspecify.annotations.Nullable;@@ -58,11 +56,11 @@ import org.slf4j.LoggerFactory;import com.fasterxml.jackson.databind.JsonNode;import com.fasterxml.jackson.databind.ObjectMapper;-import com.google.common.hash.HashingInputStream;import io.onedev.commons.utils.ExplicitException;import io.onedev.k8shelper.KubernetesHelper;import io.onedev.server.cluster.ClusterService;+import io.onedev.server.exception.HttpResponseAwareException;import io.onedev.server.model.GitLfsLock;import io.onedev.server.model.Project;import io.onedev.server.persistence.SessionService;@@ -254,50 +252,37 @@ public class GitLfsFilter implements Filter {if (lfsObject != null) {String activeServer = projectService.getActiveServer(lfsObject.getProjectId(), true);- var hash = new AtomicReference<String>(null);- try {- if (activeServer.equals(clusterService.getLocalServerAddress())) {- try (- HashingInputStream is = new HashingInputStream(- sha256(), httpRequest.getInputStream());- OutputStream os = lfsObject.getOutputStream()) {- IOUtils.copy(is, os, BUFFER_SIZE);- hash.set(Hex.encodeHexString(is.hash().asBytes()));- }- } else {- Client client = ClientBuilder.newClient();- client.property(REQUEST_ENTITY_PROCESSING, "CHUNKED");- try {- String serverUrl = clusterService.getServerUrl(activeServer);- WebTarget target = client.target(serverUrl)- .path("~api/cluster/lfs")- .queryParam("projectId", lfsObject.getProjectId())- .queryParam("objectId", lfsObject.getObjectId());- Invocation.Builder builder = target.request();- builder.header(AUTHORIZATION,- BEARER + " " + clusterService.getCredential());-- StreamingOutput os = output -> {- try (HashingInputStream is = new HashingInputStream(- sha256(), httpRequest.getInputStream())) {- IOUtils.copy(is, output, BUFFER_SIZE);- hash.set(Hex.encodeHexString(is.hash().asBytes()));- } finally {- output.close();- }- };+ if (activeServer.equals(clusterService.getLocalServerAddress())) {+ try (InputStream is = httpRequest.getInputStream()) {+ lfsObject.upload(is);+ }+ } else {+ Client client = ClientBuilder.newClient();+ client.property(REQUEST_ENTITY_PROCESSING, "CHUNKED");+ try {+ String serverUrl = clusterService.getServerUrl(activeServer);+ WebTarget target = client.target(serverUrl)+ .path("~api/cluster/lfs")+ .queryParam("projectId", lfsObject.getProjectId())+ .queryParam("objectId", lfsObject.getObjectId());+ Invocation.Builder builder = target.request();+ builder.header(AUTHORIZATION,+ BEARER + " " + clusterService.getCredential());- try (Response lfsResponse = builder.post(Entity.entity(os, APPLICATION_OCTET_STREAM))) {- KubernetesHelper.checkStatus(lfsResponse);+ StreamingOutput os = output -> {+ try (output; InputStream is = httpRequest.getInputStream()) {+ LfsObject.copyUpload(is, output);}- } finally {- client.close();+ };++ try (Response lfsResponse = builder.post(Entity.entity(os, APPLICATION_OCTET_STREAM))) {+ if (lfsResponse.getStatus() == SC_REQUEST_ENTITY_TOO_LARGE)+ throw new HttpResponseAwareException(SC_REQUEST_ENTITY_TOO_LARGE,+ lfsResponse.readEntity(String.class));+ KubernetesHelper.checkStatus(lfsResponse);}- }- } finally {- if (!objectId.equals(hash.get())) {- lfsObject.delete();- throw new RuntimeException("Invalid uploaded content: hash not equals to object id");+ } finally {+ client.close();}}}diff --git a/server-core/src/main/java/io/onedev/server/git/GitUtils.java b/server-core/src/main/java/io/onedev/server/git/GitUtils.javaindex 8b5c7c5f08..d8b77a2f7b 100644--- a/server-core/src/main/java/io/onedev/server/git/GitUtils.java+++ b/server-core/src/main/java/io/onedev/server/git/GitUtils.java@@ -806,6 +806,10 @@ public class GitUtils {}).checkReturnCode();+ // Restrict Git LFS to our trusted config. In bare repositories, GIT_CONFIG also+ // prevents its "git config --blob HEAD:.lfsconfig" from reading repository content.+ git.envs().put("GIT_CONFIG", new File(homeDir, ".gitconfig").getAbsolutePath());+return task.call(git);} catch (IOException e) {throw new RuntimeException(e);diff --git a/server-core/src/main/java/io/onedev/server/git/LfsObject.java b/server-core/src/main/java/io/onedev/server/git/LfsObject.javaindex dd0faa534c..efa2678c9b 100644--- a/server-core/src/main/java/io/onedev/server/git/LfsObject.java+++ b/server-core/src/main/java/io/onedev/server/git/LfsObject.java@@ -1,33 +1,40 @@package io.onedev.server.git;+import static com.google.common.hash.Hashing.sha256;import static io.onedev.server.util.IOUtils.BUFFER_SIZE;+import static jakarta.servlet.http.HttpServletResponse.SC_REQUEST_ENTITY_TOO_LARGE;+import static java.nio.file.StandardCopyOption.ATOMIC_MOVE;+import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;import java.io.BufferedOutputStream;import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;-import java.io.FileOutputStream;import java.io.FilterInputStream;-import java.io.FilterOutputStream;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.io.Serializable;+import java.nio.file.Files;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReadWriteLock;import java.util.regex.Pattern;import org.apache.tika.mime.MediaType;-import org.jetbrains.annotations.NotNull;import org.jspecify.annotations.Nullable;+import com.google.common.hash.HashingInputStream;+import io.onedev.commons.utils.ExplicitException;import io.onedev.commons.utils.FileUtils;import io.onedev.commons.utils.LockUtils;import io.onedev.server.OneDev;import io.onedev.server.cluster.ClusterTask;+import io.onedev.server.exception.HttpResponseAwareException;import io.onedev.server.service.ProjectService;+import io.onedev.server.service.SettingService;import io.onedev.server.util.ContentDetector;+import io.onedev.server.util.IOUtils;public class LfsObject implements Serializable {@@ -128,29 +135,36 @@ public class LfsObject implements Serializable {}}- public OutputStream getOutputStream() {- Lock writeLock = getLock().writeLock();- writeLock.lock();- try {- return new FilterOutputStream(new BufferedOutputStream(new FileOutputStream(getFile()), BUFFER_SIZE)) {- @Override- public void write(@NotNull byte[] b, int off, int len) throws IOException {- out.write(b, off, len);- }+ public static void copyUpload(InputStream input, OutputStream output) throws IOException {+ long maxSize = (long) OneDev.getInstance(SettingService.class)+ .getPerformanceSetting().getMaxGitLFSFileSize() * 1024 * 1024;+ // Read one extra byte to distinguish an exact-size upload from an oversized one.+ if (maxSize < 0 || IOUtils.copyLarge(input, output, 0, maxSize + 1, new byte[BUFFER_SIZE]) > maxSize)+ throw new HttpResponseAwareException(SC_REQUEST_ENTITY_TOO_LARGE,+ "Exceeded max acceptable LFS file size " + maxSize);+ }- @Override- public void close() throws IOException {- try {- super.close();- } finally {- writeLock.unlock();- }- }-- };- } catch (FileNotFoundException e) {- writeLock.unlock();- throw new RuntimeException(e);+ public void upload(InputStream input) throws IOException {+ File file = getFile();+ // Keep the upload on the same filesystem so publishing it can be atomic.+ var tempFile = Files.createTempFile(file.getParentFile().toPath(), "upload-", ".tmp");+ try {+ var is = new HashingInputStream(sha256(), input);+ try (OutputStream os = new BufferedOutputStream(Files.newOutputStream(tempFile), BUFFER_SIZE)) {+ copyUpload(is, os);+ }+ if (!objectId.equals(is.hash().toString()))+ throw new ExplicitException("Invalid uploaded content: hash not equals to object id");++ Lock writeLock = getLock().writeLock();+ writeLock.lock();+ try {+ Files.move(tempFile, file.toPath(), ATOMIC_MOVE, REPLACE_EXISTING);+ } finally {+ writeLock.unlock();+ }+ } finally {+ Files.deleteIfExists(tempFile);}}diff --git a/server-core/src/main/java/io/onedev/server/service/impl/DefaultProjectService.java b/server-core/src/main/java/io/onedev/server/service/impl/DefaultProjectService.javaindex 3dd49cdc21..efa7afab62 100644--- a/server-core/src/main/java/io/onedev/server/service/impl/DefaultProjectService.java+++ b/server-core/src/main/java/io/onedev/server/service/impl/DefaultProjectService.java@@ -638,7 +638,15 @@ public class DefaultProjectService extends BaseEntityService<Project>if (withLfs)// Use origin instead of real url as otherwise the command will// report EOF error when fetch from a local path- new LfsFetchAllCommand(toGitDir, "origin").run();+ new LfsFetchAllCommand(toGitDir, "origin") {+ @Override+ protected Commandline newGit() {+ var git = super.newGit();+ // Ignore HEAD:.lfsconfig while retaining the local origin URL.+ git.envs().put("GIT_CONFIG", new File(toGitDir, "config").getAbsolutePath());+ return git;+ }+ }.run();} else {var remoteUrl = clusterService.getServerUrl(fromActiveServer) + "/" + fromPath;callWithClusterCredential(git -> {diff --git a/server-core/src/test/java/io/onedev/server/git/LfsUploadTest.java b/server-core/src/test/java/io/onedev/server/git/LfsUploadTest.javanew file mode 100644index 0000000000..08cdf3a967--- /dev/null+++ b/server-core/src/test/java/io/onedev/server/git/LfsUploadTest.java@@ -0,0 +1,320 @@+package io.onedev.server.git;++import static com.google.common.hash.Hashing.sha256;+import static java.nio.charset.StandardCharsets.UTF_8;+import static org.junit.jupiter.api.Assertions.*;+import static org.mockito.Mockito.*;++import java.io.ByteArrayInputStream;+import java.io.ByteArrayOutputStream;+import java.io.FilterInputStream;+import java.io.IOException;+import java.io.InputStream;+import java.nio.file.Files;+import java.nio.file.Path;+import java.util.List;+import java.util.Set;++import org.junit.jupiter.api.AfterEach;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.io.TempDir;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.EnumSource;+import org.mockito.MockedStatic;++import com.google.common.io.CountingInputStream;++import io.onedev.commons.utils.ExplicitException;+import io.onedev.commons.utils.ExceptionUtils;+import io.onedev.server.OneDev;+import io.onedev.server.cluster.ClusterResource;+import io.onedev.server.cluster.ClusterService;+import io.onedev.server.cluster.ClusterTask;+import io.onedev.server.exception.HttpResponseAwareException;+import io.onedev.server.model.Project;+import io.onedev.server.model.support.administration.PerformanceSetting;+import io.onedev.server.persistence.SessionService;+import io.onedev.server.security.SecurityUtils;+import io.onedev.server.service.ProjectService;+import io.onedev.server.service.SettingService;+import jakarta.servlet.FilterChain;+import jakarta.servlet.ReadListener;+import jakarta.servlet.ServletInputStream;+import jakarta.servlet.http.HttpServletRequest;+import jakarta.servlet.http.HttpServletResponse;+import jakarta.ws.rs.ProcessingException;+import jakarta.ws.rs.client.Client;+import jakarta.ws.rs.client.ClientBuilder;+import jakarta.ws.rs.client.Entity;+import jakarta.ws.rs.client.Invocation;+import jakarta.ws.rs.client.WebTarget;+import jakarta.ws.rs.core.Response;+import jakarta.ws.rs.core.StreamingOutput;++class LfsUploadTest {++ enum Endpoint { DIRECT, CLUSTER, FORWARDED }++ private static final int MAX_SIZE = 1024 * 1024;++ @TempDir+ Path storage;++ private final byte[] content = "existing LFS content".getBytes(UTF_8);+ private final String objectId = sha256().hashBytes(content).toString();+ private MockedStatic<OneDev> oneDev;+ private MockedStatic<SecurityUtils> security;+ private ProjectService projects;+ private PerformanceSetting performance;+ private GitLfsFilter filter;+ private Path objectFile;+ private Response forwardedResponse;++ @BeforeEach+ void setUp() {+ projects = mock(ProjectService.class);+ when(projects.getLfsObjectsDir(1L)).thenReturn(storage.toFile());+ when(projects.getGitDir(1L)).thenReturn(storage.toFile());+ when(projects.getActiveServer(1L, true)).thenReturn("local");+ when(projects.runOnActiveServer(any(), any()))+ .thenAnswer(it -> it.getArgument(1, ClusterTask.class).call());+ var project = new Project();+ project.setId(1L);+ when(projects.findByPath("test")).thenReturn(project);+ oneDev = mockStatic(OneDev.class);+ oneDev.when(() -> OneDev.getInstance(ProjectService.class)).thenReturn(projects);+ performance = new PerformanceSetting();+ performance.setMaxGitLFSFileSize(1);+ var settings = mock(SettingService.class);+ when(settings.getPerformanceSetting()).thenReturn(performance);+ oneDev.when(() -> OneDev.getInstance(SettingService.class)).thenReturn(settings);+ security = mockStatic(SecurityUtils.class);+ security.when(() -> SecurityUtils.canAccessProject(project)).thenReturn(true);+ security.when(() -> SecurityUtils.canWriteCode(project)).thenReturn(true);+ var cluster = mock(ClusterService.class);+ when(cluster.getLocalServerAddress()).thenReturn("local");+ when(cluster.getServerUrl("remote")).thenReturn("http://active.example.invalid");+ filter = new GitLfsFilter(projects, null, mock(SessionService.class), settings, null, cluster, Set.of());+ objectFile = objectFile(objectId);+ }++ @AfterEach+ void tearDown() {+ security.close();+ oneDev.close();+ }++ @ParameterizedTest+ @EnumSource(Endpoint.class)+ void acceptsValidAndRepeatedUploads(Endpoint endpoint) throws Exception {+ upload(endpoint, new ByteArrayInputStream(content));+ upload(endpoint, new ByteArrayInputStream(content));+ assertStoredContent();+ }++ @ParameterizedTest+ @EnumSource(Endpoint.class)+ void invalidReuploadPreservesExistingObject(Endpoint endpoint) throws Exception {+ upload(endpoint, new ByteArrayInputStream(content));+ assertThrows(ExplicitException.class,+ () -> upload(endpoint, new ByteArrayInputStream(new byte[0])));+ assertStoredContent();+ }++ @ParameterizedTest+ @EnumSource(Endpoint.class)+ void interruptedReuploadPreservesExistingObject(Endpoint endpoint) throws Exception {+ upload(endpoint, new ByteArrayInputStream(content));+ assertInterruptedUpload(endpoint);+ assertStoredContent();+ }++ @ParameterizedTest+ @EnumSource(Endpoint.class)+ void failedNewUploadsLeaveNoObjectsOrTemporaryFiles(Endpoint endpoint) throws Exception {+ assertThrows(ExplicitException.class,+ () -> upload(endpoint, new ByteArrayInputStream(new byte[0])));+ assertFiles(List.of());+ assertInterruptedUpload(endpoint);+ assertFiles(List.of());+ }++ @ParameterizedTest+ @EnumSource(Endpoint.class)+ void acceptsUploadExactlyAtLimit(Endpoint endpoint) throws Exception {+ var bytes = new byte[MAX_SIZE];+ var id = sha256().hashBytes(bytes).toString();+ upload(endpoint, id, new ByteArrayInputStream(bytes));+ assertArrayEquals(bytes, Files.readAllBytes(objectFile(id)));+ assertFiles(List.of(objectFile(id)));+ }++ @ParameterizedTest+ @EnumSource(Endpoint.class)+ void stopsOversizedUploadsAfterFirstExcessByte(Endpoint endpoint) throws Exception {+ for (var size : new int[] {MAX_SIZE + 1, MAX_SIZE * 2}) {+ var bytes = new byte[size];+ var id = sha256().hashBytes(bytes).toString();+ try (var input = new CountingInputStream(new ByteArrayInputStream(bytes))) {+ assertSizeError(() -> upload(endpoint, id, input));+ assertEquals(MAX_SIZE + 1, input.getCount());+ }+ assertFiles(List.of());+ }+ }++ @ParameterizedTest+ @EnumSource(Endpoint.class)+ void oversizedReuploadPreservesExistingObject(Endpoint endpoint) throws Exception {+ upload(endpoint, new ByteArrayInputStream(content));+ assertSizeError(() -> upload(endpoint, new ByteArrayInputStream(new byte[MAX_SIZE + 1])));+ assertStoredContent();+ }++ @ParameterizedTest+ @EnumSource(Endpoint.class)+ void zeroLimitAcceptsOnlyEmptyObjects(Endpoint endpoint) throws Exception {+ performance.setMaxGitLFSFileSize(0);+ var emptyId = sha256().hashBytes(new byte[0]).toString();+ upload(endpoint, emptyId, new ByteArrayInputStream(new byte[0]));+ assertEquals(0, Files.size(objectFile(emptyId)));+ assertSizeError(() -> upload(endpoint, new ByteArrayInputStream(content)));+ assertFiles(List.of(objectFile(emptyId)));+ }++ @Test+ void preservesSizeErrorReturnedByActiveNode() {+ forwardedResponse = mock(Response.class);+ when(forwardedResponse.getStatus()).thenReturn(413);+ when(forwardedResponse.readEntity(String.class)).thenReturn("Exceeded max acceptable LFS file size 0");+ assertSizeError(() -> upload(Endpoint.FORWARDED, new ByteArrayInputStream(content)));+ verify(forwardedResponse).close();+ }++ private void assertSizeError(org.junit.jupiter.api.function.Executable upload) {+ var exception = assertThrows(Exception.class, upload);+ var cause = ExceptionUtils.find(exception, HttpResponseAwareException.class);+ assertNotNull(cause);+ assertEquals(413, cause.getHttpResponse().getStatus());+ assertTrue(cause.getMessage().startsWith("Exceeded max acceptable LFS file size "));+ }++ private void assertInterruptedUpload(Endpoint endpoint) {+ var exception = assertThrows(Exception.class, () -> upload(endpoint, interruptedInput()));+ var cause = ExceptionUtils.find(exception, IOException.class);+ assertNotNull(cause);+ assertEquals("Upload interrupted", cause.getMessage());+ }++ private InputStream interruptedInput() {+ return new FilterInputStream(new ByteArrayInputStream(content)) {+ private boolean started;++ @Override+ public int read(byte[] bytes, int offset, int length) throws IOException {+ if (started)+ throw new IOException("Upload interrupted");+ started = true;+ return super.read(bytes, offset, Math.min(length, 4));+ }+ };+ }++ private void assertStoredContent() throws IOException {+ assertArrayEquals(content, Files.readAllBytes(objectFile));+ assertFiles(List.of(objectFile));+ }++ private void assertFiles(List<Path> expected) throws IOException {+ try (var files = Files.walk(storage)) {+ assertEquals(expected, files.filter(Files::isRegularFile).toList());+ }+ }++ private void upload(Endpoint endpoint, InputStream input) throws Exception {+ upload(endpoint, objectId, input);+ }++ private Path objectFile(String id) {+ return storage.resolve(id.substring(0, 2)).resolve(id.substring(2, 4)).resolve(id);+ }++ private void upload(Endpoint endpoint, String id, InputStream input) throws Exception {+ security.when(SecurityUtils::isSystem).thenReturn(endpoint == Endpoint.CLUSTER);+ if (endpoint == Endpoint.CLUSTER) {+ try (var response = new ClusterResource().uploadLfs(input, 1L, id)) {+ assertEquals(200, response.getStatus());+ }+ } else if (endpoint == Endpoint.FORWARDED) {+ when(projects.getActiveServer(1L, true)).thenReturn("remote");+ var client = mock(Client.class);+ var target = mock(WebTarget.class, RETURNS_SELF);+ var builder = mock(Invocation.Builder.class, RETURNS_SELF);+ when(client.target(anyString())).thenReturn(target);+ when(target.request()).thenReturn(builder);+ when(builder.post(any(Entity.class))).thenAnswer(it -> {+ if (forwardedResponse != null)+ return forwardedResponse;+ var output = new ByteArrayOutputStream();+ var entity = it.getArgument(0, Entity.class);+ try {+ ((StreamingOutput) entity.getEntity()).write(output);+ } catch (IOException | RuntimeException e) {+ throw new ProcessingException(e);+ }+ security.when(SecurityUtils::isSystem).thenReturn(true);+ try {+ return new ClusterResource().uploadLfs(new ByteArrayInputStream(output.toByteArray()), 1L, id);+ } finally {+ security.when(SecurityUtils::isSystem).thenReturn(false);+ }+ });+ try (var clients = mockStatic(ClientBuilder.class)) {+ clients.when(ClientBuilder::newClient).thenReturn(client);+ upload(Endpoint.DIRECT, id, input);+ } finally {+ verify(client).close();+ }+ } else {+ var request = mock(HttpServletRequest.class);+ when(request.getRequestURI()).thenReturn("/test.git/lfs/objects/" + id);+ when(request.getContextPath()).thenReturn("");+ when(request.getParameter("lfs-objects")).thenReturn("true");+ when(request.getMethod()).thenReturn("PUT");+ when(request.getContentLengthLong()).thenReturn(-1L);+ when(request.getInputStream()).thenReturn(new ServletInputStream() {+ @Override+ public int read() throws IOException {+ return input.read();+ }++ @Override+ public int read(byte[] bytes, int offset, int length) throws IOException {+ return input.read(bytes, offset, length);+ }++ @Override+ public void close() throws IOException {+ input.close();+ }++ @Override+ public boolean isFinished() {+ return false;+ }++ @Override+ public boolean isReady() {+ return true;+ }++ @Override+ public void setReadListener(ReadListener listener) {+ throw new UnsupportedOperationException();+ }+ });+ filter.doFilter(request, mock(HttpServletResponse.class), mock(FilterChain.class));+ }+ }+}