Cómo obtener una JsonProcessingException usando Jackson

Puede ser una pregunta extraña, pero de hecho me gustaría lograr un poco más de cobertura en mis pruebas y, aunque codifiqué contra un JsonProcessingException No puedo crear una carga útil que genere esta excepción, tal vez porque Jackson es bastante inteligente y convierte todo en una cadena, e incluso para las cadenas malas se ajusta a las especificaciones de JSON. Mi problema es que Jackson es bastante bueno 🙂

Básicamente, quiero una carga útil que cuando ejecute esto, se rompa con JsonProcessingException:

String jsonPayload = objectMapper.writeValueAsString(payload);

He probado algunos como:

HashMap<String, String> invalidJSONPayload= new HashMap<>();

invalidJSONPayload.put("021",021);
invalidJSONPayload.put("---",021);
invalidJSONPayload.put("~",021);

No estoy preocupado con el tipo, así que no dude en sugerir otro. Un objeto vacío, por ejemplo, arroja JsonMappingException y ya cogí ese también.

Quería hacer lo mismo y finalmente lo logré usando la función “espía” de Mockito, que envuelve un objeto real con un objeto simulado. Todas las llamadas al objeto simulado se reenvían al objeto real, excepto aquellas que intenta simular. Por ejemplo:

ObjectMapper om = Mockito.spy(new ObjectMapper());
Mockito.when( om.writeValueAsString(ErrorObject.class)).thenThrow(new JsonProcessingException("") {});

Todos los usos de om será manejado por la instancia de ObjectMapper subyacente hasta que una instancia de ErrorObject se pasa adentro, en cuyo punto el JsonProcessingException será arrojado.

El nuevoJsonProcessingException se crea como una clase anónima, ya que es una clase protegida y solo se puede instanciar una subclase.

Partiendo de la respuesta de Liam, burlándose de la toString() El método con un ciclo también hace que Jackson se rompa.

@Test
public void forceJsonParseException() {
    try {
        Object mockItem = mock(Object.class);
        when(mockItem.toString()).thenReturn(mockItem.getClass().getName());
        new ObjectMapper().writeValueAsString(mockItem);
        fail("did not throw JsonProcessingException");
    } catch (JsonProcessingException e) {
        //pass
    }
}

EDITAR: Es mucho más fácil que eso. Un simulacro de Mockito siempre lo tirará. ooo;;

Podrías usar algo como esto:

private static class ClassThatJacksonCannotSerialize {
    private final ClassThatJacksonCannotSerialize self = this;

    @Override
    public String toString() {
        return self.getClass().getName();
   }
}

Lo cual resulta en un JsonProcessingException con mensaje Direct self-reference leading to cycle (through reference chain: ClassThatJacksonCannotSerialize["self"])

siguiendo la respuesta de @Mike.Mathieson

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.Test;

public class JacksonTest {

    @Test(expected = JsonProcessingException.class)
    // actually throws an InvalidDefinitionException (which extends JsonProcessingException)
    public void encodeThrowsException() throws JsonProcessingException {
        new ObjectMapper().writeValueAsString(new Object());
    }
}

https://fasterxml.github.io/jackson-databind/javadoc/2.9/com/fasterxml/jackson/databind/exc/InvalidDefinitionException.html

tenga en cuenta que esta prueba no funcionará si ObjectMapper se configuró para deshabilitar SerializationFeature.FAIL_ON_EMPTY_BEANSp.ej

new ObjectMapper()
    .configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false)
    .writeValueAsString(new Object());

Para mí, si una clase no tiene public campos/métodos, writeValueAsString lanzará un JsonMappingException (no serializer found for class...)

private static class ClassThatJacksonCannotSerialize {}

private void forceProcessingException() {
    ObjectMapper mapper = new ObjectMapper();
    try {
        return mapper.writeValueAsString(value);
    } 
    catch (JsonProcessingException e) {
        throw new RuntimeException(e);
    }
}

en caso de que esto pueda ayudar a alguien, cuando estaba realizando pruebas unitarias para una JsonProcessingException, seguía recibiendo este error:

JsonProcessingException has protected access in com.fasterxml.jackson...

este era mi codigo

// error is on the below line
JsonProcessingException e = new JsonProcessingException("borked");

doThrow(e).when(classMock).methodToMock(any(), any());

descubrí que solo necesitaba agregar “{}” como tal

JsonProcessingException e = new JsonProcessingException("borked") {};

Puede obtener una JsonProcessingException si asigna dos campos a la misma propiedad.

class InvalidObject {
    @JsonProperty("s")
    private String x = "value1";
    
    @JsonProperty("s")
    private String y = "value2";
}

El mensaje de excepción es “Múltiples campos que representan la propiedad “s”:…”