Unit test for JsonProcessingException

user_8096492 0
Viewed 10296

I want to write an unit test to test a JsonProcessingException. This exception can happen on the line: mapper.writeValueAsString(). 

public void myMethod(Args...) {
        try {
               ObjectMapper mapper = new ObjectMapper();
                mapper.configure(SerializationFeature.INDENT_OUTPUT, true);

                Document.parse(mapper.writeValueAsString(testObject)));
            }
        } catch (JsonProcessingException e) {
            log.error("Error parsing the object to json string. ", e);
        } 
}

and here is my unit test:

public class Test {

    @Mock
    private ObjectMapper              mapper;

    @InjectMocks
    ClassUnderTest            sut;

    @Test
    public void testJsonProcessingException() throws     JsonProcessingException {
        when(mapper.writeValueAsString(Mockito.any())).thenThrow(new     JsonProcessingException("Error parsing the object to json string. "){
            private static final long serialVersionUID = 1L;});
        sut.myMethod(args...);
    }

}

The problem is the mapper which i have mocked will not be used (i get unnecessary Mockito stubbings failure) as the mapper is again initialized inside the method. How can i unit test such a situation with mockito?

mockito mocking unit-testing json java
2 Answers

To test a method using an ObjectMapper and throws a custom exception (wrapping the JsonProcessingException), we need to mock the ObjectMapper and tell it to throw the exception.

Here's a class with a method to parse a JsonNode and throw a custom exception:

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.RequiredArgsConstructor;

@RequiredArgsConstructor
public class MyService {

    private final ObjectMapper objectMapper;

    public Boolean processSomething(JsonNode jsonNode) {

        Simple simple;
        try {
            simple = objectMapper.readValue(jsonNode.toString(), Simple.class);
        } catch (JsonProcessingException e) {
            throw new CustomServerException(e.getMessage(), e);
        }
        return true;
    }
}

To test this method:

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.my.path.MyService;
import org.assertj.core.api.Assertions;
import org.mockito.Mockito;
import org.testng.annotations.Test;

public class TestMyService {
    // To test the method for the CustomServerException,
    // we need to mock the ObjectMapper to throw the JsonProcessingException:
    @Test
    void testProcessSomething_JsonProcessingException() {

        // using a mock ObjectMapper to force a JsonProcessingException to be thrown
        ObjectMapper mockMapper = Mockito.mock(ObjectMapper.class);
        MyService serviceWithMockMapper = new MyService(mockMapper);

        CustomServerException thrown = assertThrows(CustomServerException.class, () -> {

            when(mockMapper.readValue(jsonNode.toString(), Simple.class)).thenThrow(JsonProcessingException.class);
            serviceWithMockMapper.processSomething(jsonNode);

        });

        Assertions.assertNotNull(thrown.getMessage());
    }
}
user_47751880
Related