Java Code Examples for javax.servlet.http.Part

@Test
public void resolvePartArray() throws Exception {
	MockHttpServletRequest request = new MockHttpServletRequest();
	MockPart expected1 = new MockPart("pfilearray", "Hello World 1".getBytes());
	MockPart expected2 = new MockPart("pfilearray", "Hello World 2".getBytes());
	request.setMethod("POST");
	request.setContentType("multipart/form-data");
	request.addPart(expected1);
	request.addPart(expected2);
	request.addPart(new MockPart("other", "Hello World 3".getBytes()));
	webRequest = new ServletWebRequest(request);

	MethodParameter param = this.testMethod.annotPresent(RequestParam.class).arg(Part[].class);
	Object result = resolver.resolveArgument(param, null, webRequest, null);

	assertTrue(result instanceof Part[]);
	Part[] parts = (Part[]) result;
	assertEquals(2, parts.length);
	assertEquals(parts[0], expected1);
	assertEquals(parts[1], expected2);
}
 

@Test
public void resolvePartList() throws Exception {
	MockHttpServletRequest request = new MockHttpServletRequest();
	request.setMethod("POST");
	request.setContentType("multipart/form-data");
	MockPart expected1 = new MockPart("pfilelist", "Hello World 1".getBytes());
	MockPart expected2 = new MockPart("pfilelist", "Hello World 2".getBytes());
	request.addPart(expected1);
	request.addPart(expected2);
	request.addPart(new MockPart("other", "Hello World 3".getBytes()));
	webRequest = new ServletWebRequest(request);

	MethodParameter param = this.testMethod.annotPresent(RequestParam.class).arg(List.class, Part.class);
	Object result = resolver.resolveArgument(param, null, webRequest, null);

	assertTrue(result instanceof List);
	assertEquals(Arrays.asList(expected1, expected2), result);
}
 

private void parseRequest(HttpServletRequest request) {
	try {
		Collection<Part> parts = request.getParts();
		this.multipartParameterNames = new LinkedHashSet<String>(parts.size());
		MultiValueMap<String, MultipartFile> files = new LinkedMultiValueMap<String, MultipartFile>(parts.size());
		for (Part part : parts) {
			String disposition = part.getHeader(CONTENT_DISPOSITION);
			String filename = extractFilename(disposition);
			if (filename == null) {
				filename = extractFilenameWithCharset(disposition);
			}
			if (filename != null) {
				files.add(part.getName(), new StandardMultipartFile(part, filename));
			}
			else {
				this.multipartParameterNames.add(part.getName());
			}
		}
		setMultipartFiles(files);
	}
	catch (Throwable ex) {
		throw new MultipartException("Could not parse multipart servlet request", ex);
	}
}
 

@Test
@SuppressWarnings("unchecked")
public void resolveMapOfPart() throws Exception {
	MockHttpServletRequest request = new MockHttpServletRequest();
	request.setContentType("multipart/form-data");
	Part expected1 = new MockPart("mfile", "Hello World".getBytes());
	Part expected2 = new MockPart("other", "Hello World 3".getBytes());
	request.addPart(expected1);
	request.addPart(expected2);
	webRequest = new ServletWebRequest(request);

	MethodParameter param = this.testMethod.annot(requestParam().noName()).arg(Map.class, String.class, Part.class);
	Object result = resolver.resolveArgument(param, null, webRequest, null);

	assertTrue(result instanceof Map);
	Map<String, Part> resultMap = (Map<String, Part>) result;
	assertEquals(2, resultMap.size());
	assertEquals(expected1, resultMap.get("mfile"));
	assertEquals(expected2, resultMap.get("other"));
}
 

@Test
public void sendPart_succ(@Mocked Part part, @Mocked InputStream inputStream)
    throws IOException, InterruptedException, ExecutionException {
  new Expectations() {
    {
      part.getInputStream();
      result = inputStream;
      inputStream.read((byte[]) any);
      result = -1;
    }
  };

  CompletableFuture<Void> future = response.sendPart(part);

  Assert.assertNull(future.get());
}
 

/**
 * 检查上传对象并写入目标目录
 * @param part
 * @param subn
 * @return
 * @throws Wrong
 */
public File upload(Part part, String subn) throws Wrong {
    if (part == null) {
        setResultName("", null);
        return  null;
    }

    /**
     * 从上传项中获取类型并提取扩展名
     */
    String type = part.getContentType( /**/ );
           type = getTypeByMime( type );
    String extn = part.getSubmittedFileName();
           extn = getExtnByName( extn );

    try {
        return upload(part.getInputStream(), type, extn, subn);
    }
    catch ( IOException ex) {
        throw new Wrong(ex, "fore.form.upload.failed");
    }
}
 

protected void doPost(HttpServletRequest request,
        HttpServletResponse response) throws ServletException, IOException {
    // gets absolute path of the web application
    String applicationPath = request.getServletContext().getRealPath("");
    // constructs path of the directory to save uploaded file
    String uploadFilePath = applicationPath + File.separator + UPLOAD_DIR;
     
    // creates the save directory if it does not exists
    File fileSaveDir = new File(uploadFilePath);
    if (!fileSaveDir.exists()) {
        fileSaveDir.mkdirs();
    }
    System.out.println("Upload File Directory="+fileSaveDir.getAbsolutePath());
    
    String fileName = null;
    //Get all the parts from request and write it to the file on server
    for (Part part : request.getParts()) {
        fileName = getFileName(part);
        part.write(uploadFilePath + File.separator + fileName);
    }
 
    request.setAttribute("message", fileName + " File uploaded successfully!");
    getServletContext().getRequestDispatcher("/response.jsp").forward(
            request, response);
}
 

@Test
public void resolvePartArrayArgument() throws Exception {
	MockPart part1 = new MockPart("requestPart1", "Hello World 1".getBytes());
	MockPart part2 = new MockPart("requestPart2", "Hello World 2".getBytes());
	MockHttpServletRequest request = new MockHttpServletRequest();
	request.setMethod("POST");
	request.setContentType("multipart/form-data");
	request.addPart(part1);
	request.addPart(part2);
	webRequest = new ServletWebRequest(request);

	Object result = resolver.resolveArgument(paramPartArray, null, webRequest, null);

	assertTrue(result instanceof Part[]);
	Part[] parts = (Part[]) result;
	assertThat(parts, Matchers.arrayWithSize(2));
	assertEquals(parts[0], part1);
	assertEquals(parts[1], part2);
}
 

private void parseRequest(HttpServletRequest request) {
	try {
		Collection<Part> parts = request.getParts();
		this.multipartParameterNames = new LinkedHashSet<>(parts.size());
		MultiValueMap<String, MultipartFile> files = new LinkedMultiValueMap<>(parts.size());
		for (Part part : parts) {
			String headerValue = part.getHeader(HttpHeaders.CONTENT_DISPOSITION);
			ContentDisposition disposition = ContentDisposition.parse(headerValue);
			String filename = disposition.getFilename();
			if (filename != null) {
				if (filename.startsWith("=?") && filename.endsWith("?=")) {
					filename = MimeDelegate.decode(filename);
				}
				files.add(part.getName(), new StandardMultipartFile(part, filename));
			}
			else {
				this.multipartParameterNames.add(part.getName());
			}
		}
		setMultipartFiles(files);
	}
	catch (Throwable ex) {
		handleParseFailure(ex);
	}
}
 

@Path("/uploadArray2")
@POST
@Produces(MediaType.TEXT_PLAIN)
public String uploadArray2(@FormParam("file1") Part[] file1, @FormParam("message") String message)
    throws IOException {
  StringBuilder stringBuilder = new StringBuilder();
  for (int i = 0; i < file1.length; i++) {
    stringBuilder.append(getStrFromPart(file1[i]));
  }
  return stringBuilder.append(message).toString();
}
 

@Override
public String getMultipartContentType(String paramOrFileName) {
	try {
		Part part = getPart(paramOrFileName);
		return (part != null ? part.getContentType() : null);
	}
	catch (Throwable ex) {
		throw new MultipartException("Could not access multipart servlet request", ex);
	}
}
 

@Test
public void resolvePartNotAnnot() throws Exception {
	MockPart expected = new MockPart("part", "Hello World".getBytes());
	MockHttpServletRequest request = new MockHttpServletRequest();
	request.setMethod("POST");
	request.setContentType("multipart/form-data");
	request.addPart(expected);
	webRequest = new ServletWebRequest(request);

	Object result = resolver.resolveArgument(paramPartNotAnnot, null, webRequest, null);

	assertTrue(result instanceof Part);
	assertEquals("Invalid result", expected, result);
}
 

/**
 * Test to upload a native cad to a part
 */
@Test
public void uploadNativeCADToPart() throws Exception {

    //Given
    final File fileToUpload = new File(ResourceUtil.getFilePath(ResourceUtil.SOURCE_PART_STORAGE + ResourceUtil.TEST_PART_FILENAME1));
    File uploadedFile = File.createTempFile(ResourceUtil.TARGET_PART_STORAGE + ResourceUtil.FILENAME_TARGET_PART, ResourceUtil.TEMP_SUFFIX);
    HttpServletRequestWrapper request = Mockito.mock(HttpServletRequestWrapper.class);
    Collection<Part> parts = new ArrayList<>();
    parts.add(new PartImpl(fileToUpload));
    Mockito.when(request.getParts()).thenReturn(parts);
    BinaryResource binaryResource = new BinaryResource(ResourceUtil.FILENAME1, ResourceUtil.PART_SIZE, new Date());
    OutputStream outputStream = new FileOutputStream(uploadedFile);
    Mockito.when(request.getRequestURI()).thenReturn(ResourceUtil.WORKSPACE_ID + "/parts/" + ResourceUtil.PART_TEMPLATE_ID + "/");
    Mockito.when(productService.saveNativeCADInPartIteration(Matchers.any(PartIterationKey.class), Matchers.anyString(), Matchers.anyInt())).thenReturn(binaryResource);
    Mockito.when(storageManager.getBinaryResourceOutputStream(binaryResource)).thenReturn(outputStream);

    //When
    Response response = partBinaryResource.uploadNativeCADFile(request, ResourceUtil.WORKSPACE_ID, ResourceUtil.PART_NUMBER, ResourceUtil.VERSION, ResourceUtil.ITERATION);
    //Then
    assertNotNull(response);
    assertEquals(response.getStatus(), 201);
    assertEquals(response.getStatusInfo(), Response.Status.CREATED);

    //delete temp file
    uploadedFile.deleteOnExit();

}
 

@Path("/download/schemas")
@GET
@ApiResponse(code = 200, message = "", response = File.class)
public Response downloadSchemas(@QueryParam("format") SchemaFormat format) {
  if (format == null) {
    format = SchemaFormat.SWAGGER;
  }

  // normally, schema will not be too big, just save them in memory temporarily
  ByteArrayOutputStream os = new ByteArrayOutputStream();
  try (ZipOutputStream zos = new ZipOutputStream(os)) {
    for (Entry<String, String> entry : schemas.entrySet()) {
      // begin writing a new ZIP entry, positions the stream to the start of the entry data
      zos.putNextEntry(new ZipEntry(entry.getKey() + format.getSuffix()));

      String content = entry.getValue();
      if (SchemaFormat.HTML.equals(format)) {
        content = swaggerToHtml(content);
      }
      zos.write(content.getBytes(StandardCharsets.UTF_8));
      zos.closeEntry();
    }
  } catch (Throwable e) {
    String msg = "failed to create schemas zip file, format=" + format + ".";
    LOGGER.error(msg, e);
    return Response.failResp(new InvocationException(Status.INTERNAL_SERVER_ERROR, msg));
  }

  Part part = new InputStreamPart(null, new ByteArrayInputStream(os.toByteArray()))
      .setSubmittedFileName(
          RegistrationManager.INSTANCE.getMicroservice().getServiceName() + format.getSuffix() + ".zip");
  return Response.ok(part);
}
 

public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
	LoginBean loginBean = getLoginBean(request, response);
	if (loginBean == null) {
		httpSessionTimeout(request, response);
		return;
	}
	AvatarBean bean = loginBean.getBean(AvatarBean.class);
	try {
		String postToken = (String)request.getParameter("postToken");
		loginBean.verifyPostToken(postToken);
		byte[] bytes = null;
		Collection<Part> files = request.getParts();
		int count = 0;
		for (Part filePart : files) {
			if (!filePart.getName().equals("file")) {
				continue;
			}
			if (filePart != null) {
				InputStream stream = filePart.getInputStream();
				int max = Site.MAX_UPLOAD_SIZE * 2;
				if (loginBean.isSuper()) {
					max = max * 10;
				}
				bytes = BotBean.loadImageFile(stream, true, max);
			}
			if ((bytes == null) || (bytes.length == 0)) {
				continue;
			}
			bean.importAvatar(bytes);
			count++;
		}
		if (count == 0) {
			throw new BotException("Please select the avatar files to import");
		}
		response.sendRedirect("avatar?id=" + bean.getInstanceId());
	} catch (Throwable failed) {
		loginBean.error(failed);
		response.sendRedirect("browse-avatar.jsp");
	}
}
 

/**
 * Test to upload a file to a part with special characters
 *
 * @throws Exception
 */
@Test
public void uploadFileWithSpecialCharactersToPart() throws Exception {
    //Given
    File fileToUpload = new File(ResourceUtil.getFilePath(ResourceUtil.SOURCE_PART_STORAGE) + ResourceUtil.FILENAME_TO_UPLOAD_PART_SPECIAL_CHARACTER);
    File uploadedFile = File.createTempFile(ResourceUtil.TARGET_PART_STORAGE + ResourceUtil.FILENAME_TO_UPLOAD_PART_SPECIAL_CHARACTER, ResourceUtil.TEMP_SUFFIX);
    HttpServletRequestWrapper request = Mockito.mock(HttpServletRequestWrapper.class);
    Collection<Part> parts = new ArrayList<>();
    parts.add(new PartImpl(fileToUpload));
    Mockito.when(request.getParts()).thenReturn(parts);
    BinaryResource binaryResource = new BinaryResource(ResourceUtil.FILENAME_TO_UPLOAD_PART_SPECIAL_CHARACTER, ResourceUtil.PART_SIZE, new Date());

    OutputStream outputStream = new FileOutputStream(uploadedFile);
    Mockito.when(request.getRequestURI()).thenReturn(ResourceUtil.WORKSPACE_ID + "/parts/" + ResourceUtil.PART_TEMPLATE_ID + "/");
    Mockito.when(productService.saveFileInPartIteration(Matchers.any(PartIterationKey.class), Matchers.anyString(), Matchers.anyString(), Matchers.anyInt())).thenReturn(binaryResource);
    Mockito.when(storageManager.getBinaryResourceOutputStream(binaryResource)).thenReturn(outputStream);

    //When
    Response response = partBinaryResource.uploadAttachedFiles(request, ResourceUtil.WORKSPACE_ID, ResourceUtil.PART_NUMBER, ResourceUtil.VERSION, ResourceUtil.ITERATION);
    //Then
    assertNotNull(response);
    assertEquals(response.getStatus(), 201);
    assertEquals(response.getStatusInfo(), Response.Status.CREATED);
    assertEquals(response.getLocation().toString(), (ResourceUtil.WORKSPACE_ID + "/parts/" + ResourceUtil.PART_TEMPLATE_ID + "/" + URLEncoder.encode(ResourceUtil.getFilePath(ResourceUtil.SOURCE_PART_STORAGE) + ResourceUtil.FILENAME_TO_UPLOAD_PART_SPECIAL_CHARACTER, "UTF-8")));
    //delete temp file
    uploadedFile.deleteOnExit();

}
 

/**
 * Test to upload several file to a document
 *
 * @throws Exception
 */
@Test
public void uploadSeveralFilesToDocumentsTemplates() throws Exception {

    //Given
    HttpServletRequestWrapper request = Mockito.mock(HttpServletRequestWrapper.class);
    Collection<Part> filesParts = new ArrayList<>();
    filesParts.add(new PartImpl(new File(ResourceUtil.getFilePath(ResourceUtil.SOURCE_FILE_STORAGE + ResourceUtil.FILENAME1))));
    filesParts.add(new PartImpl(new File(ResourceUtil.getFilePath(ResourceUtil.SOURCE_FILE_STORAGE) + ResourceUtil.FILENAME2)));
    filesParts.add(new PartImpl(new File(ResourceUtil.getFilePath(ResourceUtil.SOURCE_FILE_STORAGE + ResourceUtil.FILENAME3))));

    BinaryResource binaryResource1 = new BinaryResource(ResourceUtil.FILENAME1, ResourceUtil.DOCUMENT_SIZE, new Date());
    BinaryResource binaryResource2 = new BinaryResource(ResourceUtil.FILENAME2, ResourceUtil.DOCUMENT_SIZE, new Date());
    BinaryResource binaryResource3 = new BinaryResource(ResourceUtil.FILENAME3, ResourceUtil.DOCUMENT_SIZE, new Date());

    File uploadedFile1 = File.createTempFile(ResourceUtil.TARGET_FILE_STORAGE + "new_" + ResourceUtil.FILENAME1, ResourceUtil.TEMP_SUFFIX);
    File uploadedFile2 = File.createTempFile(ResourceUtil.TARGET_FILE_STORAGE + "new_" + ResourceUtil.FILENAME2, ResourceUtil.TEMP_SUFFIX);
    File uploadedFile3 = File.createTempFile(ResourceUtil.TARGET_FILE_STORAGE + "new_" + ResourceUtil.FILENAME3, ResourceUtil.TEMP_SUFFIX);

    OutputStream outputStream1 = new FileOutputStream(uploadedFile1);
    OutputStream outputStream2 = new FileOutputStream(uploadedFile2);
    OutputStream outputStream3 = new FileOutputStream(uploadedFile3);
    Mockito.when(request.getParts()).thenReturn(filesParts);
    Mockito.when(documentService.saveFileInDocument(Matchers.any(DocumentIterationKey.class), Matchers.anyString(), Matchers.anyInt())).thenReturn(binaryResource1, binaryResource1, binaryResource2, binaryResource2, binaryResource3, binaryResource3);
    Mockito.when(storageManager.getBinaryResourceOutputStream(Matchers.any(BinaryResource.class))).thenReturn(outputStream1, outputStream2, outputStream3);
    //When
    Response response = documentBinaryResource.uploadDocumentFiles(request, ResourceUtil.WORKSPACE_ID, ResourceUtil.DOCUMENT_ID, ResourceUtil.VERSION, ResourceUtil.ITERATION);

    //Then
    assertNotNull(response);
    assertEquals(Response.Status.NO_CONTENT, response.getStatusInfo());

    //delete temp files
    uploadedFile1.deleteOnExit();
    uploadedFile2.deleteOnExit();
    uploadedFile3.deleteOnExit();

}
 

@RequestMapping(method = RequestMethod.POST, path = "/multipartFilenames",
		consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
		produces = MediaType.TEXT_PLAIN_VALUE)
String multipartFilenames(HttpServletRequest request) throws Exception {
	return request.getParts().stream().map(Part::getSubmittedFileName)
			.collect(Collectors.joining(","));
}
 

private String uploadAFile(String workspaceId, Part formPart, ProductInstanceIterationKey pdtIterationKey)
        throws EntityNotFoundException, EntityAlreadyExistsException, AccessRightException, NotAllowedException, CreationException, UserNotActiveException, StorageException, IOException, WorkspaceNotEnabledException {

    String fileName = Normalizer.normalize(formPart.getSubmittedFileName(), Normalizer.Form.NFC);
    // Init the binary resource with a null length
    BinaryResource binaryResource = productInstanceManagerLocal.saveFileInProductInstance(workspaceId, pdtIterationKey, fileName, 0);
    OutputStream outputStream = storageManager.getBinaryResourceOutputStream(binaryResource);
    long length = BinaryResourceUpload.uploadBinary(outputStream, formPart);
    productInstanceManagerLocal.saveFileInProductInstance(workspaceId, pdtIterationKey, fileName, (int) length);
    return fileName;
}
 

@Test
public void resolvePart() throws Exception {
	MockHttpServletRequest request = new MockHttpServletRequest();
	MockPart expected = new MockPart("pfile", "Hello World".getBytes());
	request.setMethod("POST");
	request.setContentType("multipart/form-data");
	request.addPart(expected);
	webRequest = new ServletWebRequest(request);

	MethodParameter param = this.testMethod.annotPresent(RequestParam.class).arg(Part.class);
	Object result = resolver.resolveArgument(param, null, webRequest, null);

	assertTrue(result instanceof Part);
	assertEquals("Invalid result", expected, result);
}
 

@Override
public String getMultipartContentType(String paramOrFileName) {
	try {
		Part part = getPart(paramOrFileName);
		return (part != null ? part.getContentType() : null);
	}
	catch (Exception ex) {
		throw new MultipartException("Could not access multipart servlet request", ex);
	}
}
 

/**
 * Test to upload a file to a document with special characters
 *
 * @throws Exception
 */
@Test
public void uploadFileWithSpecialCharactersToDocumentTemplates() throws Exception {

    //Given
    HttpServletRequestWrapper request = Mockito.mock(HttpServletRequestWrapper.class);
    Collection<Part> filesParts = new ArrayList<>();
    filesParts.add(new PartImpl(new File(ResourceUtil.getFilePath(ResourceUtil.SOURCE_FILE_STORAGE) + ResourceUtil.FILENAME2)));

    BinaryResource binaryResource = new BinaryResource(Tools.unAccent(ResourceUtil.FILENAME2), ResourceUtil.DOCUMENT_SIZE, new Date());

    File uploadedFile1 = File.createTempFile(ResourceUtil.TARGET_FILE_STORAGE + "new_" + ResourceUtil.FILENAME2, ResourceUtil.TEMP_SUFFIX);


    OutputStream outputStream1 = new FileOutputStream(uploadedFile1);

    Mockito.when(request.getParts()).thenReturn(filesParts);
    Mockito.when(documentService.saveFileInDocument(Matchers.any(DocumentIterationKey.class), Matchers.anyString(), Matchers.anyInt())).thenReturn(binaryResource);
    Mockito.when(storageManager.getBinaryResourceOutputStream(Matchers.any(BinaryResource.class))).thenReturn(outputStream1);
    Mockito.when(request.getRequestURI()).thenReturn(ResourceUtil.WORKSPACE_ID + "/documents/" + ResourceUtil.DOCUMENT_ID + "/" + ResourceUtil.FILENAME2);


    //When
    Response response = documentBinaryResource.uploadDocumentFiles(request, ResourceUtil.WORKSPACE_ID, ResourceUtil.DOCUMENT_ID, ResourceUtil.VERSION, ResourceUtil.ITERATION);

    //Then
    assertNotNull(response);
    assertEquals(201, response.getStatus());
    assertEquals(Response.Status.CREATED, response.getStatusInfo());

    //delete tem file
    uploadedFile1.deleteOnExit();
}
 

private void testDownloadHtmlById(String schemaId) throws IOException {
  Response response = inspector.getSchemaContentById(schemaId, SchemaFormat.HTML, true);

  Part part = response.getResult();
  Assert.assertEquals(schemaId + ".html", part.getSubmittedFileName());
  Assert.assertNull(response.getHeaders().getFirst(HttpHeaders.CONTENT_DISPOSITION));
  Assert.assertEquals(MediaType.TEXT_HTML, response.getHeaders().getFirst(HttpHeaders.CONTENT_TYPE));

  try (InputStream is = part.getInputStream()) {
    Assert.assertTrue(IOUtils.toString(is, StandardCharsets.UTF_8).endsWith("</html>"));
  }
}
 

private static String getStrFromPart(Part file1) {
  try (InputStream is1 = file1.getInputStream()) {
    return IOUtils.toString(is1, "utf-8");
  } catch (IOException e) {
    e.printStackTrace();
  }
  return "";
}
 

@Override
public Collection<Part> getParts() throws IOException, IllegalStateException, ServletException {
	List<Part> result = new LinkedList<Part>();
	for (List<Part> list : this.parts.values()) {
		result.addAll(list);
	}
	return result;
}
 

@Override
public Collection<Part> getParts() throws IOException, ServletException {
	List<Part> result = new LinkedList<>();
	for (List<Part> list : this.parts.values()) {
		result.addAll(list);
	}
	return result;
}
 

@Test
public void sendPart_failed(@Mocked Part part) throws Throwable {
  RuntimeException error = new RuntimeExceptionWithoutStackTrace();
  new Expectations() {
    {
      response.getOutputStream();
      result = error;
    }
  };

  expectedException.expect(Matchers.sameInstance(error));

  responseEx.sendPart(part).get();
}
 

@Atomic(mode = TxMode.WRITE)
public void createFileFromRequest(Post post, Part part) throws IOException {
    AdminPosts.ensureCanEditPost(post);
    GroupBasedFile groupBasedFile = new GroupBasedFile(part.getName(), part.getName(),
            part.getInputStream(), Group.logged());

    PostFile postFile = new PostFile(post, groupBasedFile, false, 0);
    post.addFiles(postFile);
}
 

@Override
public Collection<Part> getParts() throws IOException, ServletException {
    if (parts == null) { // assume it is not init
        parts = CommonsFileUploadPartFactory.read(this);
    }
    return parts;
}
 

@Test
public void asyncBeforeSendResponse_part(@Mocked RestOperationMeta restOperationMeta) {
  ResponsesMeta responsesMeta = new ResponsesMeta();
  responsesMeta.getResponseMap().put(202, RestObjectMapperFactory.getRestObjectMapper().constructType(Part.class));
  new Expectations(RestMetaUtils.class) {
    {
      responseEx.getAttribute(RestConst.INVOCATION_HANDLER_RESPONSE);
      result = response;
      response.getResult();
      result = part;
      response.getStatusCode();
      result = 202;
      invocation.findResponseType(202);
      result = TypeFactory.defaultInstance().constructType(Part.class);
    }
  };
  new MockUp<HttpServletResponseEx>(responseEx) {
    @Mock
    CompletableFuture<Void> sendPart(Part body) {
      invokedSendPart = true;
      return null;
    }
  };

  Assert.assertNull(filter.beforeSendResponseAsync(invocation, responseEx));
  Assert.assertTrue(invokedSendPart);
}