It is easier to test MultipartFile upload service in POSTMAN just by selecting multiple files and sending the request. But to test using Java, we need to write multiple lines of code to invoke the request. In this blog, we will discuss about the Java function to invoke MultipartFile upload request and get the response.

So, below are the steps carried out to upload the file in the request.

Convert the file to MultipartFile
GetByteArray of the multipart file
Invoke request by adding the byteArray to body of the request

For instance, let us take the below example of File upload service. This service allows us to select n number of files and gives the count of the files as response

Method: POST

Url                    : http://localhost:8080/upload
Body                 :
Key           : file
Value          : (Select files from system)
Response         : 200 OK
Response body: Count of the files attached

Step 1: Convert the file to MultipartFile

Firstly, we need to convert the file to multipartFile.  I have used a sample json file “requestBody1.json”. It is placed under “src/test/resources” in the Java project. The below function converts the file to multipart file using MockMultipartFile with filename, contentType, content which has file as bytes.

Following are the Parameters used by the function

filename = “requestBody1.json”.

filePath= “src/test/resources”.

contentType= “application/json”.

Following are the Imports used by the function

import org.springframework.web.multipart.MultipartFile;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import org.springframework.mock.web.MockMultipartFile;

Below is the function which converts the file to MultipartFile

public MultipartFile getMultipartFile(String fileName) {

Path path=Paths.get(filePath);

String name= fileName;

String originalFileName = fileName;

String contType = contentType;

byte[] content = null;

try {

content = Files.readAllBytes(path);

}catch (final IOException e) {}

MultipartFile result = new MockMultipartFile(name, originalFileName, contType, content);

return result;

}

Step 2: GetByteArray of the MultipartFile

Secondly, after converting the file to multipartFile, we need to get the byteArray of the multipartfile to add it to the body, so that we can invoke the request with the files.

Following are the Parameters used by the function

filename = “requestBody1.json”

contentType= “application/json”

parameterName=”file” (please refer postman screenshot to find the parameter name)

Following are the Imports used by the function

import org.springframework.util.LinkedMultiValueMap;

import org.springframework.http.HttpEntity;

Below is the function to get the multipartFile in ByteArray

public HttpEntity<byte[]> getFileInByteArray(String fileName) throws IOException{

MultipartFile file=getMultipartFile(fileName);

//Get byteArray of the file

LinkedMultiValueMap<String,String> headerMap = new LinkedMultiValueMap<>();

headerMap.add(“Content-disposition”, “form-data; name=” + parameterName + “; filename=” +file.getOriginalFilename());

headerMap.add(“Content-type”, contentType);

HttpEntity<byte[]> doc = new HttpEntity<byte[]>(file.getBytes(),headerMap);

return doc;

}

Step 3: Invoke MultipartFile request

Thirdly, add the byteArray of the file to the body of the request. First, declare the body as MultiValueMap. Then, add the byteArray which we got from previous two functions to the body. After that, set the content type of the header to Multipart form data. Finally, add body and headers to the HttpEntity.

Below is the function to invoke the multipartFile upload Request

MultiValueMap<String,Object> body=new LinkedMultiValueMap();

//Add file in ByteArray to body

body.add(parameterName, getFileInByteArray(file));

//Set the headers

HttpHeaders headers = new HttpHeaders();

headers.setContentType(MediaType.MULTIPART_FORM_DATA);

//Add body and headers to HttpEntity

HttpEntity<MultiValueMap<String, Object>> entity= new HttpEntity<>(body,headers);

//Post the request

ResponseEntity<String>  response=new RestTemplate().postForEntity(“http://localhost:8080/upload”, entity, String.class);

Step 4: Response Verification

The response we get by invoking the request is stored as ResponseEntity. Finally, we can verify the  response code  and the count of the files attached. Converting the response to JSONObject (org.json) will make the response validation easier. For the example we have used, we are verifying the response code to be 200 and count to be 2.

assertEquals(true,200==response.getStatusCodeValue());

JSONObject obj= new JSONObject(response.getBody());

int cnt=obj.getInt(“count”);

assertEquals(true,cnt==2);

Conclusion

In this blog, you have successfully attached the files in the request and validated the response.

The following github url gives the testing code using cucumber framework

https://github.com/lav16kosh/test-multipartFile-upload-api.git