So erhalten Sie eine JsonProcessingException mit Jackson

Könnte eine seltsame Frage sein, aber in der Tat würde ich gerne ein bisschen mehr Abdeckung bei meinen Tests erreichen und obwohl ich gegen a codiert habe JsonProcessingException Ich kann keine Payload erstellen, die diese Ausnahme generiert, vielleicht weil Jackson ziemlich schlau ist und alles in eine Zeichenfolge konvertiert, und selbst bei schlechten Zeichenfolgen umgeht es die JSON-Spezifikationen. Mein Problem ist, dass Jackson ziemlich gut ist 🙂

Ich möchte im Grunde eine Nutzlast, mit der sie bricht, wenn ich sie ausführe JsonProcessingException:

String jsonPayload = objectMapper.writeValueAsString(payload);

Ich habe einige ausprobiert wie:

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

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

Ich bin nicht mit dem Typ beschäftigt, also fühlen Sie sich frei, einen anderen vorzuschlagen. Ein leeres Objekt zum Beispiel throws JsonMappingException und den fange ich auch schon.

Ich wollte dasselbe tun und habe es schließlich erreicht, indem ich die Mockito-Spionagefunktion verwendet habe, die ein echtes Objekt mit einem Scheinobjekt umschließt. Alle Aufrufe an das Scheinobjekt werden an das echte Objekt weitergeleitet, mit Ausnahme der Aufrufe, die Sie verspotten möchten. Zum Beispiel:

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

Alle Verwendungen von om wird von der zugrunde liegenden ObjectMapper-Instanz verarbeitet, bis eine Instanz von ErrorObject übergeben wird, an welcher Stelle die JsonProcessingException wird geworfen.

Das neueJsonProcessingException wird als anonyme Klasse erstellt, da es sich um eine geschützte Klasse handelt und nur eine Unterklasse instanziiert werden kann.

Aufbauend auf Liams Antwort, verspottend toString() Methode mit einem Zyklus verursacht auch Jackson zu brechen.

@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
    }
}

EDIT: Es ist viel einfacher als das. Ein Mockito-Mock wird es immer werfen. ooh;;

Sie könnten so etwas verwenden:

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

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

Was zu einem führt JsonProcessingException mit Nachricht Direct self-reference leading to cycle (through reference chain: ClassThatJacksonCannotSerialize["self"])

im Anschluss an die Antwort von @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

Beachten Sie, dass dieser Test nicht funktioniert, wenn der ObjectMapper so konfiguriert wurde, dass er deaktiviert ist SerializationFeature.FAIL_ON_EMPTY_BEANSz.B

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

Für mich, wenn eine Klasse keine hat public Felder/Methoden, writeValueAsString wird a werfen 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);
    }
}

Nur für den Fall, dass dies jemandem helfen kann, als ich Einheitentests für eine JsonProcessingException durchgeführt habe, habe ich immer wieder diesen Fehler erhalten:

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

das war mein Code

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

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

Ich fand heraus, dass ich nur “{}” als solches hinzufügen musste

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

Sie können eine JsonProcessingException erhalten, wenn Sie zwei Felder derselben Eigenschaft zuordnen.

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

Die Ausnahmemeldung lautet „Mehrere Felder, die die Eigenschaft „s“ darstellen:…“