javax.json.JsonMergePatch Java Examples

@Test
@SneakyThrows
public void updateContactUsingJsonMergePatch_shouldReturn204_whenInputIsValidAndContactExists() {

    when(service.findContact(anyLong())).thenReturn(Optional.of(contactPersisted()));

    mockMvc.perform(patch("/contacts/{id}", 1L)
            .contentType(PatchMediaType.APPLICATION_MERGE_PATCH_VALUE)
            .content(fromFile("json/contact/patch-with-valid-json-merge-patch-payload.json")))
            .andDo(print())
            .andExpect(status().isNoContent());

    verify(mapper).asInput(any(Contact.class));
    verify(mapper).update(any(Contact.class), any(ContactResourceInput.class));

    verify(patchHelper).mergePatch(any(JsonMergePatch.class), isA(ContactResourceInput.class), eq(ContactResourceInput.class));
    verifyNoMoreInteractions(patchHelper);

    ArgumentCaptor<Contact> contactArgumentCaptor = ArgumentCaptor.forClass(Contact.class);
    verify(service).findContact(anyLong());
    verify(service).updateContact(contactArgumentCaptor.capture());
    verifyNoMoreInteractions(service);

    assertThat(contactArgumentCaptor.getValue()).isEqualToComparingFieldByFieldRecursively(contactToUpdate());
}
 

@Override
protected JsonMergePatch readInternal(Class<? extends JsonMergePatch> clazz, HttpInputMessage inputMessage)
        throws HttpMessageNotReadableException {

    try (JsonReader reader = Json.createReader(inputMessage.getBody())) {
        return Json.createMergePatch(reader.readValue());
    } catch (Exception e) {
        throw new HttpMessageNotReadableException(e.getMessage(), inputMessage);
    }
}
 

@Override
protected void writeInternal(JsonMergePatch jsonMergePatch, HttpOutputMessage outputMessage)
        throws HttpMessageNotWritableException {

    try (JsonWriter writer = Json.createWriter(outputMessage.getBody())) {
        writer.write(jsonMergePatch.toJsonValue());
    } catch (Exception e) {
        throw new HttpMessageNotWritableException(e.getMessage(), e);
    }
}
 

@PatchMapping(path = "/{id}", consumes = PatchMediaType.APPLICATION_MERGE_PATCH_VALUE)
public ResponseEntity<Void> updateContact(@PathVariable Long id,
                                          @RequestBody JsonMergePatch mergePatchDocument) {

    Contact contact = service.findContact(id).orElseThrow(ResourceNotFoundException::new);
    ContactResourceInput contactResource = mapper.asInput(contact);
    ContactResourceInput contactResourcePatched = patchHelper.mergePatch(mergePatchDocument, contactResource, ContactResourceInput.class);

    mapper.update(contact, contactResourcePatched);
    service.updateContact(contact);

    return ResponseEntity.noContent().build();
}
 

private JsonValue applyMergePatch(JsonMergePatch mergePatch, JsonValue target) {
    try {
        return mergePatch.apply(target);
    } catch (Exception e) {
        throw new UnprocessableEntityException(e);
    }
}
 

@Test
public void givenSourceAndTarget_shouldCreateMergePatch() {
    JsonMergeDiffExample jsonMergeDiffExample = new JsonMergeDiffExample();
    JsonMergePatch mergePatch = jsonMergeDiffExample.createMergePatch();
    JsonString jsonString = (JsonString) mergePatch.toJsonValue();

    assertThat(jsonString.getString()).isEqualToIgnoringCase("{\"colour\":\"red\"}");
}
 

@Override
protected boolean supports(Class<?> clazz) {
    return JsonMergePatch.class.isAssignableFrom(clazz);
}
 

public JsonValue changeValue() {
    JsonValue source = Json.createValue("{\"colour\":\"blue\"}");
    JsonValue patch = Json.createValue("{\"colour\":\"red\"}");
    JsonMergePatch jsonMergePatch = Json.createMergePatch(patch);
    return jsonMergePatch.apply(source);
}
 

public JsonValue addValue() {
    JsonValue source = Json.createValue("{\"colour\":\"blue\"}");
    JsonValue patch = Json.createValue("{\"blue\":\"light\"}");
    JsonMergePatch jsonMergePatch = Json.createMergePatch(patch);
    return jsonMergePatch.apply(source);
}
 

public JsonValue deleteValue() {
    JsonValue source = Json.createValue("{\"colour\":\"blue\"}");
    JsonValue patch = Json.createValue("{\"colour\":null}");
    JsonMergePatch jsonMergePatch = Json.createMergePatch(patch);
    return jsonMergePatch.apply(source);
}
 

public JsonMergePatch createMergePatch(){
    JsonValue source = Json.createValue("{\"colour\":\"blue\"}");
    JsonValue target = Json.createValue("{\"colour\":\"red\"}");
    JsonMergePatch jsonMergePatch = Json.createMergeDiff(source, target);
    return jsonMergePatch;
}
 

@Override
public JsonMergePatch createMergePatch(final JsonValue patch) {
    return jsonpProvider.createMergePatch(patch);
}
 

@Override
public JsonMergePatch createMergeDiff(final JsonValue source, final JsonValue target) {
    return jsonpProvider.createMergeDiff(source, target);
}
 

@Override
public JsonMergePatch createMergePatch(final JsonValue patch) {
    return provider.createMergePatch(patch);
}
 

@Override
public JsonMergePatch createMergeDiff(final JsonValue source, final JsonValue target) {
    return provider.createMergeDiff(source, target);
}