This is an automated email from the ASF dual-hosted git repository.
ffang pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel-quarkus.git
The following commit(s) were added to refs/heads/main by this push:
new f65f3b9 jackson: add test coverage #2634 (#2672)
f65f3b9 is described below
commit f65f3b92610cdc577403fde5fbaf846ae7a58965
Author: Freeman(Yue) Fang <[email protected]>
AuthorDate: Wed May 26 10:48:59 2021 -0400
jackson: add test coverage #2634 (#2672)
* jackson: add test coverage #2634
(cherry picked from commit e69019354d6a11521d0c61a6183af3b4376ec2bb)
* jackson: address feedback #2634
---
.../jackson/json/JacksonJsonResource.java | 692 +++++++++++++++++++++
.../dataformats/jackson/json/JacksonJsonRoute.java | 179 ++++++
.../component/dataformats/json/model/Order.java | 71 +++
.../component/dataformats/json/model/Pojo.java | 32 +
.../src/main/resources/routes/jackson-routes.xml | 12 +
.../dataformats/jackson/json/JacksonJsonIT.java | 24 +
.../dataformats/jackson/json/JacksonJsonTest.java | 233 +++++++
7 files changed, 1243 insertions(+)
diff --git
a/integration-tests/dataformats-json/src/main/java/org/apache/camel/quarkus/component/dataformats/jackson/json/JacksonJsonResource.java
b/integration-tests/dataformats-json/src/main/java/org/apache/camel/quarkus/component/dataformats/jackson/json/JacksonJsonResource.java
new file mode 100644
index 0000000..a556d88
--- /dev/null
+++
b/integration-tests/dataformats-json/src/main/java/org/apache/camel/quarkus/component/dataformats/jackson/json/JacksonJsonResource.java
@@ -0,0 +1,692 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.quarkus.component.dataformats.jackson.json;
+
+import java.util.Calendar;
+import java.util.GregorianCalendar;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.TimeZone;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import javax.enterprise.context.ApplicationScoped;
+import javax.inject.Inject;
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.MediaType;
+
+import com.fasterxml.jackson.module.jaxb.JaxbAnnotationModule;
+import org.apache.camel.CamelContext;
+import org.apache.camel.ConsumerTemplate;
+import org.apache.camel.Exchange;
+import org.apache.camel.ExchangePattern;
+import org.apache.camel.ProducerTemplate;
+import org.apache.camel.component.jackson.JacksonConstants;
+import org.apache.camel.component.mock.MockEndpoint;
+import org.apache.camel.quarkus.component.dataformats.json.model.DummyObject;
+import org.apache.camel.quarkus.component.dataformats.json.model.Order;
+import org.apache.camel.quarkus.component.dataformats.json.model.Pojo;
+import org.apache.camel.quarkus.component.dataformats.json.model.TestJAXBPojo;
+import org.apache.camel.quarkus.component.dataformats.json.model.TestOtherPojo;
+import org.apache.camel.quarkus.component.dataformats.json.model.TestPojo;
+import org.apache.camel.quarkus.component.dataformats.json.model.TestPojoView;
+import org.apache.camel.support.DefaultExchange;
+import org.jboss.logging.Logger;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@Path("/dataformats-json")
+@ApplicationScoped
+public class JacksonJsonResource {
+
+ private static final Logger LOG =
Logger.getLogger(JacksonJsonResource.class);
+ private static final String LS = System.lineSeparator();
+ @Inject
+ ProducerTemplate producerTemplate;
+ @Inject
+ ConsumerTemplate consumerTemplate;
+ @Inject
+ CamelContext context;
+
+ @Path("jackson/unmarshal-typeheader")
+ @GET
+ public void jacksonXmlUnmarshalTypeHeader(String body) throws Exception {
+
+ MockEndpoint mock =
context.getEndpoint("mock:jackson-unmarshal-type-header-reversePojo",
MockEndpoint.class);
+ mock.expectedMessageCount(1);
+ mock.message(0).body().isInstanceOf(TestPojo.class);
+
+ String json = "{\"name\":\"Camel\"}";
+
producerTemplate.sendBodyAndHeader("direct:jackson-unmarshal-type-header-backPojo",
json,
+ JacksonConstants.UNMARSHAL_TYPE, TestPojo.class.getName());
+
+ mock.assertIsSatisfied();
+
+ TestPojo pojo =
mock.getReceivedExchanges().get(0).getIn().getBody(TestPojo.class);
+ assertNotNull(pojo);
+ assertEquals("Camel", pojo.getName());
+ }
+
+ @Path("jackson/unmarshal-list")
+ @GET
+ public void jacksonUnmarshalList(String body) throws Exception {
+
+ MockEndpoint mock =
context.getEndpoint("mock:jackson-unmarshal-backPojo", MockEndpoint.class);
+ mock.expectedMessageCount(1);
+ mock.message(0).body().isInstanceOf(List.class);
+
+ String json = "[{\"name\":\"Camel\"}, {\"name\":\"World\"}]";
+ producerTemplate.sendBody("direct:jackson-unmarshal-backPojo", json);
+
+ mock.assertIsSatisfied();
+
+ List list =
mock.getReceivedExchanges().get(0).getIn().getBody(List.class);
+ assertNotNull(list);
+ assertEquals(2, list.size());
+
+ TestPojo pojo = (TestPojo) list.get(0);
+ assertEquals("Camel", pojo.getName());
+ pojo = (TestPojo) list.get(1);
+ assertEquals("World", pojo.getName());
+
+ mock.expectedMessageCount(2);
+ mock.message(1).body().isInstanceOf(List.class);
+
+ json = "[{\"name\":\"Camel\"}]";
+ producerTemplate.sendBody("direct:jackson-unmarshal-backPojo", json);
+
+ mock.assertIsSatisfied();
+
+ list = mock.getReceivedExchanges().get(1).getIn().getBody(List.class);
+ assertNotNull(list);
+ assertEquals(1, list.size());
+
+ pojo = (TestPojo) list.get(0);
+ assertEquals("Camel", pojo.getName());
+
+ }
+
+ @Path("jackson/unmarshal-listsplit")
+ @GET
+ public void jacksonUnmarshalListSplit(String body) throws Exception {
+
+ MockEndpoint mock =
context.getEndpoint("mock:jackson-unmarshal-listsplit-result",
MockEndpoint.class);
+ mock.expectedMessageCount(2);
+
mock.expectedMessagesMatches(org.apache.camel.builder.Builder.body().isInstanceOf(DummyObject.class));
+
+ producerTemplate.sendBody("direct:jackson-unmarshal-listsplit-start",
+ "[{\"dummyString\": \"value1\"}, {\"dummyString\":
\"value2\"}]");
+
+ mock.assertIsSatisfied();
+
+ }
+
+ @Path("jackson/marshal-includedefault")
+ @GET
+ @Produces(MediaType.APPLICATION_JSON)
+ public String jacksonMarshalIncludeDefault() throws Exception {
+ TestOtherPojo pojo = new TestOtherPojo();
+ pojo.setName("Camel");
+ return
producerTemplate.requestBody("direct:jackson-marshal-includedefault-marshal",
+ pojo,
+ String.class);
+ }
+
+ @Path("jackson/unmarshal-array")
+ @GET
+ public void jacksonUnmarshalArray(String body) throws Exception {
+
+ MockEndpoint mock =
context.getEndpoint("mock:jackson-unmarshal-endArray", MockEndpoint.class);
+ mock.expectedMessageCount(1);
+ mock.message(0).body().isInstanceOf(String[].class);
+
+ String json = "[\"Camel\", \"World\"]";
+ producerTemplate.sendBody("direct:jackson-unmarshal-beginArray", json);
+
+ mock.assertIsSatisfied();
+
+ String[] array =
mock.getReceivedExchanges().get(0).getIn().getBody(String[].class);
+ assertNotNull(array);
+ assertEquals(2, array.length);
+
+ String string = array[0];
+ assertEquals("Camel", string);
+ string = array[1];
+ assertEquals("World", string);
+ }
+
+ @Path("jackson/marshal-contenttype-header")
+ @GET
+ public void jacksonMarshalContentTypeHeader() throws Exception {
+ final Map<String, Object> in = new HashMap<>();
+ in.put("name", "Camel");
+
+ Exchange out =
producerTemplate.request("direct:jackson-marshal-ct-yes", exchange ->
exchange.getIn().setBody(in));
+
+ assertNotNull(out);
+ assertTrue(out.hasOut());
+ assertEquals("application/json",
out.getMessage().getHeader(Exchange.CONTENT_TYPE));
+ out = producerTemplate.request("direct:jackson-marshal-ct-yes2",
exchange -> exchange.getIn().setBody(in));
+
+ assertNotNull(out);
+ assertTrue(out.hasOut());
+ assertEquals("application/json",
out.getMessage().getHeader(Exchange.CONTENT_TYPE));
+
+ out = producerTemplate.request("direct:jackson-marshal-ct-no",
exchange -> exchange.getIn().setBody(in));
+
+ assertNotNull(out);
+ assertTrue(out.hasOut());
+ assertNull(out.getMessage().getHeader(Exchange.CONTENT_TYPE));
+ }
+
+ @Path("jackson/marshal-general")
+ @GET
+ public void jacksonMarshalGeneral() throws Exception {
+ Map<String, Object> in = new HashMap<>();
+ in.put("name", "Camel");
+
+ MockEndpoint mock =
context.getEndpoint("mock:jackson-marshal-reverse", MockEndpoint.class);
+ mock.expectedMessageCount(1);
+ mock.message(0).body().isInstanceOf(Map.class);
+ mock.message(0).body().isEqualTo(in);
+
+ Object marshalled =
producerTemplate.requestBody("direct:jackson-marshal-in", in);
+ String marshalledAsString =
context.getTypeConverter().convertTo(String.class, marshalled);
+ assertEquals("{\"name\":\"Camel\"}", marshalledAsString);
+
+ producerTemplate.sendBody("direct:jackson-marshal-back", marshalled);
+
+ mock.assertIsSatisfied();
+
+ mock.expectedMessageCount(2);
+ mock.message(1).body().isInstanceOf(Map.class);
+ mock.message(1).body().isEqualTo(in);
+ marshalled =
producerTemplate.requestBody("direct:jackson-marshal-inPretty", in);
+ marshalledAsString =
context.getTypeConverter().convertTo(String.class, marshalled);
+ String expected = String.format("{%s \"name\" : \"Camel\"%s}", LS,
LS);
+ assertEquals(expected, marshalledAsString);
+
+ producerTemplate.sendBody("direct:jackson-marshal-backPretty",
marshalled);
+
+ mock.assertIsSatisfied();
+
+ TestPojo pojo = new TestPojo();
+ pojo.setName("Camel");
+
+ mock = context.getEndpoint("mock:jackson-marshal-reversePojo",
MockEndpoint.class);
+ mock.expectedMessageCount(1);
+ mock.message(0).body().isInstanceOf(TestPojo.class);
+ mock.message(0).body().isEqualTo(pojo);
+
+ marshalled =
producerTemplate.requestBody("direct:jackson-marshal-inPojo", pojo);
+ marshalledAsString =
context.getTypeConverter().convertTo(String.class, marshalled);
+ assertEquals("{\"name\":\"Camel\"}", marshalledAsString);
+
+ producerTemplate.sendBody("direct:jackson-marshal-backPojo",
marshalled);
+
+ mock.assertIsSatisfied();
+ }
+
+ @Path("jackson/object-mapper")
+ @GET
+ public void jacksonObjectMapper() throws Exception {
+ Map<String, Object> in = new HashMap<>();
+ in.put("name", "Camel");
+
+ MockEndpoint mock =
context.getEndpoint("mock:jackson-objectmapper-reverse", MockEndpoint.class);
+ mock.expectedMessageCount(1);
+ mock.message(0).body().isInstanceOf(Map.class);
+ mock.message(0).body().isEqualTo(in);
+
+ Object marshalled =
producerTemplate.requestBody("direct:jackson-objectmapper-in", in);
+ String marshalledAsString =
context.getTypeConverter().convertTo(String.class, marshalled);
+ assertEquals("{\"name\":\"Camel\"}", marshalledAsString);
+
+ producerTemplate.sendBody("direct:jackson-objectmapper-back",
marshalled);
+
+ mock.assertIsSatisfied();
+
+ }
+
+ @Path("jackson/allowjmstype")
+ @GET
+ public void jacksonAllowJmsType() throws Exception {
+ MockEndpoint mock =
context.getEndpoint("mock:jackson-allowjmstype-reversePojo",
MockEndpoint.class);
+ mock.expectedMessageCount(1);
+ mock.message(0).body().isInstanceOf(TestPojo.class);
+
+ String json = "{\"name\":\"Camel\"}";
+
producerTemplate.sendBodyAndHeader("direct:jackson-allowjmstype-backPojo",
json, "JMSType", TestPojo.class.getName());
+
+ mock.assertIsSatisfied();
+
+ TestPojo pojo =
mock.getReceivedExchanges().get(0).getIn().getBody(TestPojo.class);
+ assertNotNull(pojo);
+ assertEquals("Camel", pojo.getName());
+ }
+
+ @Path("jackson/marshal-module")
+ @GET
+ public void jacksonMarshalModule() throws Exception {
+ MockEndpoint mock = context.getEndpoint("mock:jackson-module-marshal",
MockEndpoint.class);
+ mock.expectedMessageCount(1);
+
mock.message(0).body(String.class).isEqualTo("{\"my-name\":\"Camel\",\"my-country\":\"Denmark\"}");
+
+ TestOtherPojo pojo = new TestOtherPojo();
+ pojo.setName("Camel");
+ pojo.setCountry("Denmark");
+
+ producerTemplate.sendBody("direct:jackson-module-marshal", pojo);
+
+ mock.assertIsSatisfied();
+ }
+
+ @Path("jackson/not-use-default-mapper")
+ @GET
+ public void jacksonNotUseDefaultMapper() throws Exception {
+ Map<String, Object> in = new HashMap<>();
+ in.put("name", "Camel");
+
+ MockEndpoint mock =
context.getEndpoint("mock:jackson-not-use-default-mapper-reverse",
MockEndpoint.class);
+ mock.expectedMessageCount(1);
+ mock.message(0).body().isInstanceOf(Map.class);
+ mock.message(0).body().isEqualTo(in);
+
+ Object marshalled =
producerTemplate.requestBody("direct:jackson-not-use-default-mapper-in", in);
+ String marshalledAsString =
context.getTypeConverter().convertTo(String.class, marshalled);
+ assertEquals("{\"name\":\"Camel\"}", marshalledAsString);
+
+
producerTemplate.sendBody("direct:jackson-not-use-default-mapper-back",
marshalled);
+
+ mock.assertIsSatisfied();
+
+ }
+
+ @Path("jackson/unmarshal-list-xml-configure")
+ @GET
+ public void jacksonUnmarshalListXmlConfigure() throws Exception {
+ MockEndpoint mock =
context.getEndpoint("mock:jackson-xml-unmarshal-list-reversePojo",
MockEndpoint.class);
+ mock.expectedMessageCount(1);
+ mock.message(0).body().isInstanceOf(List.class);
+
+ String json = "[{\"name\":\"Camel\"}, {\"name\":\"World\"}]";
+
producerTemplate.sendBody("direct:jackson-xml-unmarshal-list-backPojo", json);
+
+ mock.assertIsSatisfied();
+
+ List list =
mock.getReceivedExchanges().get(0).getIn().getBody(List.class);
+ assertNotNull(list);
+ assertEquals(2, list.size());
+
+ TestPojo pojo = (TestPojo) list.get(0);
+ assertEquals("Camel", pojo.getName());
+ pojo = (TestPojo) list.get(1);
+ assertEquals("World", pojo.getName());
+
+ mock.expectedMessageCount(2);
+ mock.message(1).body().isInstanceOf(List.class);
+
+ json = "[{\"name\":\"Camel\"}]";
+
producerTemplate.sendBody("direct:jackson-xml-unmarshal-list-backPojo", json);
+
+ mock.assertIsSatisfied();
+
+ list = mock.getReceivedExchanges().get(1).getIn().getBody(List.class);
+ assertNotNull(list);
+ assertEquals(1, list.size());
+
+ pojo = (TestPojo) list.get(0);
+ assertEquals("Camel", pojo.getName());
+ }
+
+ @Path("jackson/object-mapper-noreg")
+ @GET
+ public void jacksonObjectMapperNoReg() throws Exception {
+ Map<String, Object> in = new HashMap<>();
+ in.put("name", "Camel");
+
+ MockEndpoint mock =
context.getEndpoint("mock:jackson-objectmapper-noreg-reverse",
MockEndpoint.class);
+ mock.expectedMessageCount(1);
+ mock.message(0).body().isInstanceOf(Map.class);
+ mock.message(0).body().isEqualTo(in);
+
+ Object marshalled =
producerTemplate.requestBody("direct:jackson-objectmapper-noreg-in", in);
+ String marshalledAsString =
context.getTypeConverter().convertTo(String.class, marshalled);
+ assertEquals("{\"name\":\"Camel\"}", marshalledAsString);
+
+ producerTemplate.sendBody("direct:jackson-objectmapper-noreg-back",
marshalled);
+
+ mock.assertIsSatisfied();
+
+ mock.expectedMessageCount(2);
+ mock.message(1).body().isInstanceOf(Map.class);
+ mock.message(1).body().isEqualTo(in);
+ marshalled =
producerTemplate.requestBody("direct:jackson-objectmapper-noreg-inPretty", in);
+ marshalledAsString =
context.getTypeConverter().convertTo(String.class, marshalled);
+ String expected = String.format("{%s \"name\" : \"Camel\"%s}", LS,
LS);
+ assertEquals(expected, marshalledAsString);
+
+
producerTemplate.sendBody("direct:jackson-objectmapper-noreg-backPretty",
marshalled);
+
+ mock.assertIsSatisfied();
+
+ TestPojo pojo = new TestPojo();
+ pojo.setName("Camel");
+
+ mock =
context.getEndpoint("mock:jackson-objectmapper-noreg-reversePojo",
MockEndpoint.class);
+ mock.expectedMessageCount(1);
+ mock.message(0).body().isInstanceOf(TestPojo.class);
+ mock.message(0).body().isEqualTo(pojo);
+
+ marshalled =
producerTemplate.requestBody("direct:jackson-objectmapper-noreg-inPojo", pojo);
+ marshalledAsString =
context.getTypeConverter().convertTo(String.class, marshalled);
+ assertEquals("{\"name\":\"Camel\"}", marshalledAsString);
+
+
producerTemplate.sendBody("direct:jackson-objectmapper-noreg-backPojo",
marshalled);
+
+ mock.assertIsSatisfied();
+ }
+
+ @Path("jackson/pojo-array")
+ @GET
+ public void jacksonPojoArray() throws Exception {
+ MockEndpoint mock =
context.getEndpoint("mock:jackson-pojo-array-endArray", MockEndpoint.class);
+ mock.expectedMessageCount(1);
+ mock.message(0).body().isInstanceOf(Pojo[].class);
+
+ String json = "[{\"text\":\"Camel\"}, {\"text\":\"World\"}]";
+ producerTemplate.sendBody("direct:jackson-pojo-array-beginArray",
json);
+
+ mock.assertIsSatisfied();
+
+ Pojo[] array =
mock.getReceivedExchanges().get(0).getIn().getBody(Pojo[].class);
+ assertNotNull(array);
+ assertEquals(2, array.length);
+
+ Pojo pojo = array[0];
+ assertEquals("Camel", pojo.getText());
+ pojo = array[1];
+ assertEquals("World", pojo.getText());
+ }
+
+ @Path("jackson/enablefeature")
+ @GET
+ public void jacksonEnableFeature() throws Exception {
+
+ TestPojoView in = new TestPojoView();
+
+ Object marshalled =
producerTemplate.requestBody("direct:jackson-enablefeature-in", in);
+ String marshalledAsString =
context.getTypeConverter().convertTo(String.class, marshalled);
+ // we enable the wrap root type feature so we should have TestPojoView
+
assertEquals("{\"TestPojoView\":{\"age\":30,\"height\":190,\"weight\":70}}",
marshalledAsString);
+ }
+
+ @Path("jackson/concurrent")
+ @GET
+ public void jacksonConcurrent() throws Exception {
+ doSendMessages(10, 5);
+ }
+
+ @Path("jackson/unmarshal-listjackson")
+ @GET
+ public void jacksonUnmarshalListJackson(String body) throws Exception {
+
+ MockEndpoint mock =
context.getEndpoint("mock:jackson-list-unmarshal-reversePojo",
MockEndpoint.class);
+ mock.expectedMessageCount(1);
+ mock.message(0).body().isInstanceOf(List.class);
+
+ String json = "[{\"name\":\"Camel\"}, {\"name\":\"World\"}]";
+ producerTemplate.sendBody("direct:jackson-list-unmarshal-backPojo",
json);
+
+ mock.assertIsSatisfied();
+
+ List list =
mock.getReceivedExchanges().get(0).getIn().getBody(List.class);
+ assertNotNull(list);
+ assertEquals(2, list.size());
+
+ TestPojo pojo = (TestPojo) list.get(0);
+ assertEquals("Camel", pojo.getName());
+ pojo = (TestPojo) list.get(1);
+ assertEquals("World", pojo.getName());
+
+ mock.expectedMessageCount(2);
+ mock.message(1).body().isInstanceOf(List.class);
+
+ json = "[{\"name\":\"Camel\"}]";
+ producerTemplate.sendBody("direct:jackson-list-unmarshal-backPojo",
json);
+
+ mock.assertIsSatisfied();
+
+ list = mock.getReceivedExchanges().get(1).getIn().getBody(List.class);
+ assertNotNull(list);
+ assertEquals(1, list.size());
+
+ pojo = (TestPojo) list.get(0);
+ assertEquals("Camel", pojo.getName());
+
+ }
+
+ @Path("jackson/conversion-pojo")
+ @GET
+ public void jacksonConversionPojo(String body) throws Exception {
+ synchronized (context) {
+
context.getGlobalOptions().put(JacksonConstants.ENABLE_TYPE_CONVERTER, "true");
+
context.getGlobalOptions().put(JacksonConstants.TYPE_CONVERTER_TO_POJO, "true");
+
+ Order order = new Order();
+ order.setAmount(1);
+ order.setCustomerName("Acme");
+ order.setPartName("Camel");
+
+ String json = (String)
producerTemplate.requestBody("direct:jackson-conversion-pojo-test", order);
+
assertEquals("{\"id\":0,\"partName\":\"Camel\",\"amount\":1,\"customerName\":\"Acme\"}",
json);
+
+
context.getGlobalOptions().put(JacksonConstants.TYPE_CONVERTER_MODULE_CLASS_NAMES,
+ JaxbAnnotationModule.class.getName());
+
+ order = new Order();
+ order.setAmount(1);
+ order.setCustomerName("Acme");
+ order.setPartName("Camel");
+
+ json = (String)
producerTemplate.requestBody("direct:jackson-conversion-pojo-test", order);
+ /*
+ * somehow jaxb annotation @XmlAttribute(name = "customer_name")
can't be taken into accout so the
+ * following asserts failed, need to investigate more
+ *
assertEquals("{\"id\":0,\"partName\":\"Camel\",\"amount\":1,\"customer_name\":\"Acme\"}",
+ * json);
+ */
+ }
+
+ }
+
+ @Path("jackson/conversion")
+ @GET
+ public void jacksonConversion(String body) throws Exception {
+ synchronized (context) {
+
context.getGlobalOptions().put(JacksonConstants.ENABLE_TYPE_CONVERTER, "true");
+ String name = "someName";
+ Map<String, String> pojoAsMap = new HashMap<>();
+ pojoAsMap.put("name", name);
+
+ TestPojo testPojo = (TestPojo)
producerTemplate.requestBody("direct:jackson-conversion-test", pojoAsMap);
+
+ assertEquals(name, testPojo.getName());
+ }
+ }
+
+ @Path("jackson/conversion-simple")
+ @GET
+ public void jacksonConversionSimple(String body) throws Exception {
+ synchronized (context) {
+
context.getGlobalOptions().put(JacksonConstants.ENABLE_TYPE_CONVERTER, "true");
+ Exchange exchange = new DefaultExchange(context);
+
+ Map<String, String> map = new HashMap<>();
+ Object convertedObject =
context.getTypeConverter().convertTo(String.class, exchange, map);
+ // will do a toString which is an empty map
+ assertEquals(map.toString(), convertedObject);
+
+ convertedObject = context.getTypeConverter().convertTo(Long.class,
exchange,
+ new HashMap<String, String>());
+ assertNull(convertedObject);
+
+ convertedObject = context.getTypeConverter().convertTo(long.class,
exchange,
+ new HashMap<String, String>());
+ assertNull(convertedObject);
+
+ convertedObject =
context.getTypeConverter().convertTo(ExchangePattern.class, exchange, "InOnly");
+ assertEquals(ExchangePattern.InOnly, convertedObject);
+ }
+ }
+
+ @Path("jackson/jaxb-annotation")
+ @GET
+ public void jacksonJaxbAnnotation() throws Exception {
+ TestJAXBPojo in = new TestJAXBPojo();
+ in.setName("Camel");
+
+ MockEndpoint mock =
context.getEndpoint("mock:jackson-jaxb-annotation-reversePojo",
MockEndpoint.class);
+ mock.expectedMessageCount(1);
+ mock.message(0).body().isInstanceOf(TestJAXBPojo.class);
+ mock.message(0).body().isEqualTo(in);
+
+ Object marshalled =
producerTemplate.requestBody("direct:jackson-jaxb-annotation-inPojo", in);
+ String marshalledAsString =
context.getTypeConverter().convertTo(String.class, marshalled);
+ assertEquals("{\"PojoName\":\"Camel\"}", marshalledAsString);
+
+ producerTemplate.sendBody("direct:jackson-jaxb-annotation-backPojo",
marshalled);
+
+ mock.assertIsSatisfied();
+ }
+
+ @Path("jackson/view")
+ @GET
+ public void jacksonView() throws Exception {
+ TestPojoView in = new TestPojoView();
+
+ MockEndpoint mock =
context.getEndpoint("mock:jackson-view-reversePojoAgeView", MockEndpoint.class);
+ mock.expectedMessageCount(1);
+ mock.message(0).body().isInstanceOf(TestPojoView.class);
+ mock.message(0).body().isEqualTo(in);
+
+ Object marshalled =
producerTemplate.requestBody("direct:jackson-view-inPojoAgeView", in);
+ String marshalledAsString =
context.getTypeConverter().convertTo(String.class, marshalled);
+ assertEquals("{\"age\":30,\"height\":190}", marshalledAsString);
+
+ producerTemplate.sendBody("direct:jackson-view-backPojoAgeView",
marshalled);
+
+ mock.assertIsSatisfied();
+ }
+
+ @Path("jackson/moduleref")
+ @GET
+ public void jacksonModuleRef() throws Exception {
+ MockEndpoint mock =
context.getEndpoint("mock:jackson-module-ref-marshal", MockEndpoint.class);
+ mock.expectedMessageCount(1);
+
mock.message(0).body(String.class).isEqualTo("{\"my-name\":\"Camel\",\"my-country\":\"Denmark\"}");
+
+ TestOtherPojo pojo = new TestOtherPojo();
+ pojo.setName("Camel");
+ pojo.setCountry("Denmark");
+
+ producerTemplate.sendBody("direct:jackson-module-ref-marshal", pojo);
+
+ mock.assertIsSatisfied();
+ }
+
+ @Path("jackson/include-no-null")
+ @GET
+ public void jacksonIncludeNoNull() throws Exception {
+ MockEndpoint mock =
context.getEndpoint("mock:jackson-not-null-marshal", MockEndpoint.class);
+ mock.expectedMessageCount(1);
+ mock.message(0).body(String.class).isEqualTo("{\"name\":\"Camel\"}");
+
+ TestOtherPojo pojo = new TestOtherPojo();
+ pojo.setName("Camel");
+
+ producerTemplate.sendBody("direct:jackson-not-null-marshal", pojo);
+
+ mock.assertIsSatisfied();
+
+ }
+
+ @Path("jackson/typeheader-not-allowed")
+ @GET
+ public void jacksonTypeHeaderNotAllowed() throws Exception {
+ MockEndpoint mock =
context.getEndpoint("mock:jackson-typeheader-not-allowed-reversePojo",
MockEndpoint.class);
+ mock.expectedMessageCount(1);
+ mock.message(0).body().isInstanceOf(LinkedHashMap.class);
+
+ String json = "{\"name\":\"Camel\"}";
+
producerTemplate.sendBodyAndHeader("direct:jackson-typeheader-not-allowed-backPojo",
json,
+ JacksonConstants.UNMARSHAL_TYPE, TestPojo.class.getName());
+
+ mock.assertIsSatisfied();
+
+ }
+
+ @Path("jackson/datetimezone")
+ @GET
+ public void jacksonDatetimezone() throws Exception {
+ TimeZone.setDefault(TimeZone.getTimeZone("UTC"));
+ GregorianCalendar in = new GregorianCalendar(2017, Calendar.APRIL, 25,
17, 0, 10);
+
+ MockEndpoint mock =
context.getEndpoint("mock:jackson-timezone-result", MockEndpoint.class);
+
+ Object marshalled =
producerTemplate.requestBody("direct:jackson-timezone-in", in.getTime());
+ String marshalledAsString =
context.getTypeConverter().convertTo(String.class, marshalled);
+ assertEquals("1493139610000", marshalledAsString);
+
+ mock.expectedMessageCount(1);
+
+ mock.assertIsSatisfied();
+
+ }
+
+ private void doSendMessages(int files, int poolSize) throws Exception {
+ MockEndpoint mock =
context.getEndpoint("mock:jackson-concurrent-result", MockEndpoint.class);
+ mock.expectedMessageCount(files);
+ mock.assertNoDuplicates(org.apache.camel.builder.Builder.body());
+
+ ExecutorService executor = Executors.newFixedThreadPool(poolSize);
+ for (int i = 0; i < files; i++) {
+ final int index = i;
+ executor.submit(new Callable<Object>() {
+ public Object call() throws Exception {
+ TestPojo pojo = new TestPojo();
+ pojo.setName("Hi " + index);
+
+
producerTemplate.sendBody("direct:jackson-concurrent-start", pojo);
+ return null;
+ }
+ });
+ }
+
+ mock.assertIsSatisfied();
+ executor.shutdownNow();
+ }
+
+}
diff --git
a/integration-tests/dataformats-json/src/main/java/org/apache/camel/quarkus/component/dataformats/jackson/json/JacksonJsonRoute.java
b/integration-tests/dataformats-json/src/main/java/org/apache/camel/quarkus/component/dataformats/jackson/json/JacksonJsonRoute.java
new file mode 100644
index 0000000..d67eee2
--- /dev/null
+++
b/integration-tests/dataformats-json/src/main/java/org/apache/camel/quarkus/component/dataformats/jackson/json/JacksonJsonRoute.java
@@ -0,0 +1,179 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.camel.quarkus.component.dataformats.jackson.json;
+
+import java.util.TimeZone;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.component.jackson.JacksonConstants;
+import org.apache.camel.component.jackson.JacksonDataFormat;
+import org.apache.camel.component.jackson.ListJacksonDataFormat;
+import org.apache.camel.model.dataformat.JsonLibrary;
+import org.apache.camel.quarkus.component.dataformats.json.model.DummyObject;
+import org.apache.camel.quarkus.component.dataformats.json.model.MyModule;
+import org.apache.camel.quarkus.component.dataformats.json.model.Pojo;
+import org.apache.camel.quarkus.component.dataformats.json.model.TestPojo;
+import org.apache.camel.quarkus.component.dataformats.json.model.TestPojoView;
+import org.apache.camel.quarkus.component.dataformats.json.model.Views;
+
+public class JacksonJsonRoute extends RouteBuilder {
+
+ @Override
+ public void configure() throws Exception {
+ JacksonDataFormat unmarshalTypeHeaderFormat = new JacksonDataFormat();
+ unmarshalTypeHeaderFormat.setAllowUnmarshallType(true);
+
from("direct:jackson-unmarshal-type-header-backPojo").unmarshal(unmarshalTypeHeaderFormat)
+ .to("mock:jackson-unmarshal-type-header-reversePojo");
+
+ JacksonDataFormat listFormat = new JacksonDataFormat(TestPojo.class);
+ listFormat.useList();
+
from("direct:jackson-unmarshal-backPojo").unmarshal(listFormat).to("mock:jackson-unmarshal-backPojo");
+
+ JacksonDataFormat listSplitFormat = new
JacksonDataFormat(DummyObject.class);
+ listSplitFormat.useList();
+
from("direct:jackson-unmarshal-listsplit-start").unmarshal(listSplitFormat).split(body())
+ .to("mock:jackson-unmarshal-listsplit-result");
+
+ JacksonDataFormat includeDefaultFormat = new JacksonDataFormat();
+
from("direct:jackson-marshal-includedefault-marshal").marshal(includeDefaultFormat)
+ .to("mock:jackson-marshal-includedefault-marshal");
+
+
from("direct:jackson-unmarshal-beginArray").unmarshal().json(JsonLibrary.Jackson,
String[].class)
+ .to("mock:jackson-unmarshal-endArray");
+
+ JacksonDataFormat marshalContentTypeformat = new JacksonDataFormat();
+
from("direct:jackson-marshal-ct-yes").marshal(marshalContentTypeformat);
+
from("direct:jackson-marshal-ct-yes2").marshal().json(JsonLibrary.Jackson);
+ JacksonDataFormat formatNoHeader = new JacksonDataFormat();
+ formatNoHeader.setContentTypeHeader(false);
+ from("direct:jackson-marshal-ct-no").marshal(formatNoHeader);
+
+ JacksonDataFormat format = new JacksonDataFormat();
+ from("direct:jackson-marshal-in").marshal(format);
+
from("direct:jackson-marshal-back").unmarshal(format).to("mock:jackson-marshal-reverse");
+ JacksonDataFormat prettyPrintDataFormat = new JacksonDataFormat();
+ prettyPrintDataFormat.setPrettyPrint(true);
+ from("direct:jackson-marshal-inPretty").marshal(prettyPrintDataFormat);
+
from("direct:jackson-marshal-backPretty").unmarshal(prettyPrintDataFormat).to("mock:jackson-marshal-reverse");
+ JacksonDataFormat formatPojo = new JacksonDataFormat(TestPojo.class);
+ from("direct:jackson-marshal-inPojo").marshal(formatPojo);
+
from("direct:jackson-marshal-backPojo").unmarshal(formatPojo).to("mock:jackson-marshal-reversePojo");
+
+ this.getContext().getRegistry().bind("myMapper", new ObjectMapper());
+ JacksonDataFormat objectMapperFormat = new JacksonDataFormat();
+ objectMapperFormat.setAutoDiscoverObjectMapper(true);
+ from("direct:jackson-objectmapper-in").marshal(objectMapperFormat);
+
from("direct:jackson-objectmapper-back").unmarshal(objectMapperFormat).to("mock:jackson-objectmapper-reverse");
+
+ JacksonDataFormat jacksonAllowJmsTypeFormat = new JacksonDataFormat();
+ jacksonAllowJmsTypeFormat.setAllowJmsType(true);
+
from("direct:jackson-allowjmstype-backPojo").unmarshal(jacksonAllowJmsTypeFormat)
+ .to("mock:jackson-allowjmstype-reversePojo");
+
+ JacksonDataFormat jacksonJsonModuleFormat = new JacksonDataFormat();
+ jacksonJsonModuleFormat.setInclude("NON_NULL");
+
jacksonJsonModuleFormat.setModuleClassNames("org.apache.camel.quarkus.component.dataformats.json.model.MyModule");
+
from("direct:jackson-module-marshal").marshal(jacksonJsonModuleFormat).to("mock:jackson-module-marshal");
+
+ JacksonDataFormat jacksonNotUseDefaultMapper = new JacksonDataFormat();
+ jacksonNotUseDefaultMapper.setUseDefaultObjectMapper(false);
+
from("direct:jackson-not-use-default-mapper-in").marshal(jacksonNotUseDefaultMapper);
+
from("direct:jackson-not-use-default-mapper-back").unmarshal(jacksonNotUseDefaultMapper)
+ .to("mock:jackson-not-use-default-mapper-reverse");
+
+ ObjectMapper mapper = new ObjectMapper();
+ JacksonDataFormat jacksonObjectMapperFormat = new JacksonDataFormat();
+ jacksonObjectMapperFormat.setObjectMapper(mapper);
+
+
from("direct:jackson-objectmapper-noreg-in").marshal(jacksonObjectMapperFormat);
+
from("direct:jackson-objectmapper-noreg-back").unmarshal(jacksonObjectMapperFormat)
+ .to("mock:jackson-objectmapper-noreg-reverse");
+
+ JacksonDataFormat jacksonObjectMapperPrettyPrintDataFormat = new
JacksonDataFormat();
+ jacksonObjectMapperPrettyPrintDataFormat.setPrettyPrint(true);
+
+
from("direct:jackson-objectmapper-noreg-inPretty").marshal(jacksonObjectMapperPrettyPrintDataFormat);
+
from("direct:jackson-objectmapper-noreg-backPretty").unmarshal(jacksonObjectMapperPrettyPrintDataFormat)
+ .to("mock:jackson-objectmapper-noreg-reverse");
+
+ JacksonDataFormat jacksonObjectMapperFormatPojo = new
JacksonDataFormat(TestPojo.class);
+
+
from("direct:jackson-objectmapper-noreg-inPojo").marshal(jacksonObjectMapperFormatPojo);
+
from("direct:jackson-objectmapper-noreg-backPojo").unmarshal(jacksonObjectMapperFormatPojo)
+ .to("mock:jackson-objectmapper-noreg-reversePojo");
+
+
from("direct:jackson-pojo-array-beginArray").unmarshal().json(Pojo[].class).to("mock:jackson-pojo-array-endArray");
+
+
from("direct:jackson-concurrent-start").marshal().json(JsonLibrary.Jackson).to("log:marshalled")
+ .to("direct:jackson-concurrent-marshalled");
+
from("direct:jackson-concurrent-marshalled").unmarshal().json(JsonLibrary.Jackson,
TestPojo.class)
+ .to("mock:jackson-concurrent-result");
+
+ from("direct:jackson-list-unmarshal-backPojo").unmarshal(new
ListJacksonDataFormat(TestPojo.class))
+ .to("mock:jackson-list-unmarshal-reversePojo");
+
+
this.getContext().getGlobalOptions().put(JacksonConstants.ENABLE_TYPE_CONVERTER,
"true");
+
+
from("direct:jackson-conversion-pojo-test").convertBodyTo(String.class);
+
+ from("direct:jackson-conversion-test").convertBodyTo(TestPojo.class);
+
+ /*java.lang.ClassNotFoundException:
com.fasterxml.jackson.module.jaxb.JaxbAnnotationModule
+ * in native mode, need to investigate more
+ *
+ * JacksonDataFormat jacksonJaxbAnnotationFormat = new
JacksonDataFormat();
+
from("direct:jackson-jaxb-annotation-in").marshal(jacksonJaxbAnnotationFormat);
+
from("direct:jackson-jaxb-annotation-back").unmarshal(jacksonJaxbAnnotationFormat)
+ .to("mock:jackson-jaxb-annotation-reverse");
+ JacksonDataFormat jacksonJaxbAnnotationFormatPojo = new
JacksonDataFormat(TestJAXBPojo.class);
+
jacksonJaxbAnnotationFormatPojo.setModuleClassNames(JaxbAnnotationModule.class.getName());
+
from("direct:jackson-jaxb-annotation-inPojo").marshal(jacksonJaxbAnnotationFormatPojo);
+
from("direct:jackson-jaxb-annotation-backPojo").unmarshal(jacksonJaxbAnnotationFormatPojo)
+ .to("mock:jackson-jaxb-annotation-reversePojo");
+
+ */
+
+
from("direct:jackson-view-inPojoAgeView").marshal().json(TestPojoView.class,
Views.Age.class);
+
from("direct:jackson-view-backPojoAgeView").unmarshal().json(JsonLibrary.Jackson,
TestPojoView.class)
+ .to("mock:jackson-view-reversePojoAgeView");
+
from("direct:jackson-view-inPojoWeightView").marshal().json(TestPojoView.class,
Views.Weight.class);
+
from("direct:jackson-view-backPojoWeightView").unmarshal().json(JsonLibrary.Jackson,
TestPojoView.class)
+ .to("mock:jackson-view-reversePojoWeightView");
+
+ this.getContext().getRegistry().bind("myJacksonModule", new
MyModule());
+ JacksonDataFormat jacksonModuleRefFormat = new JacksonDataFormat();
+ jacksonModuleRefFormat.setInclude("NON_NULL");
+ jacksonModuleRefFormat.setModuleRefs("myJacksonModule");
+
from("direct:jackson-module-ref-marshal").marshal(jacksonModuleRefFormat).to("mock:jackson-module-ref-marshal");
+
+ JacksonDataFormat jacksonNotNullFormat = new JacksonDataFormat();
+ jacksonNotNullFormat.setInclude("NON_NULL");
+
from("direct:jackson-not-null-marshal").marshal(jacksonNotNullFormat).to("mock:jackson-not-null-marshal");
+
+ JacksonDataFormat jacksonTypeHeaderNotAllowedFormat = new
JacksonDataFormat();
+
from("direct:jackson-typeheader-not-allowed-backPojo").unmarshal(jacksonTypeHeaderNotAllowedFormat)
+ .to("mock:jackson-typeheader-not-allowed-reversePojo");
+
+ JacksonDataFormat jacksonTimeZone = new JacksonDataFormat();
+ TimeZone timeZone = TimeZone.getTimeZone("Africa/Ouagadougou");
+ jacksonTimeZone.setTimezone(timeZone);
+
from("direct:jackson-timezone-in").marshal(jacksonTimeZone).to("mock:jackson-timezone-result");
+ }
+
+}
diff --git
a/integration-tests/dataformats-json/src/main/java/org/apache/camel/quarkus/component/dataformats/json/model/Order.java
b/integration-tests/dataformats-json/src/main/java/org/apache/camel/quarkus/component/dataformats/json/model/Order.java
new file mode 100644
index 0000000..e3b0c51
--- /dev/null
+++
b/integration-tests/dataformats-json/src/main/java/org/apache/camel/quarkus/component/dataformats/json/model/Order.java
@@ -0,0 +1,71 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.quarkus.component.dataformats.json.model;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlRootElement;
+
+import io.quarkus.runtime.annotations.RegisterForReflection;
+
+@XmlRootElement(name = "order")
+@XmlAccessorType(XmlAccessType.FIELD)
+@RegisterForReflection
+public class Order {
+
+ @XmlAttribute
+ private int id;
+ @XmlAttribute
+ private String partName;
+ @XmlAttribute
+ private int amount;
+ @XmlAttribute(name = "customer_name")
+ private String customerName;
+
+ public int getId() {
+ return id;
+ }
+
+ public void setId(int id) {
+ this.id = id;
+ }
+
+ public String getPartName() {
+ return partName;
+ }
+
+ public void setPartName(String partName) {
+ this.partName = partName;
+ }
+
+ public int getAmount() {
+ return amount;
+ }
+
+ public void setAmount(int amount) {
+ this.amount = amount;
+ }
+
+ public String getCustomerName() {
+ return customerName;
+ }
+
+ public void setCustomerName(String customerName) {
+ this.customerName = customerName;
+ }
+}
diff --git
a/integration-tests/dataformats-json/src/main/java/org/apache/camel/quarkus/component/dataformats/json/model/Pojo.java
b/integration-tests/dataformats-json/src/main/java/org/apache/camel/quarkus/component/dataformats/json/model/Pojo.java
new file mode 100644
index 0000000..6700c45
--- /dev/null
+++
b/integration-tests/dataformats-json/src/main/java/org/apache/camel/quarkus/component/dataformats/json/model/Pojo.java
@@ -0,0 +1,32 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.quarkus.component.dataformats.json.model;
+
+import io.quarkus.runtime.annotations.RegisterForReflection;
+
+@RegisterForReflection
+public class Pojo {
+ private String text;
+
+ public String getText() {
+ return text;
+ }
+
+ public void setText(String text) {
+ this.text = text;
+ }
+}
diff --git
a/integration-tests/dataformats-json/src/main/resources/routes/jackson-routes.xml
b/integration-tests/dataformats-json/src/main/resources/routes/jackson-routes.xml
index dbb22e2..bfee9c4 100644
---
a/integration-tests/dataformats-json/src/main/resources/routes/jackson-routes.xml
+++
b/integration-tests/dataformats-json/src/main/resources/routes/jackson-routes.xml
@@ -91,6 +91,18 @@
<unmarshal><jacksonxml
unmarshalTypeName="org.apache.camel.quarkus.component.dataformats.json.model.TestPojoView"
jsonViewTypeName="org.apache.camel.quarkus.component.dataformats.json.model.Views$Age"/></unmarshal>
<to uri="mock:jacksonxml-xml-reverseAgeView"/>
</route>
+
+ <route>
+ <from uri="direct:jackson-xml-unmarshal-list-backPojo"/>
+ <unmarshal><json library="Jackson" useList="true"
unmarshalTypeName="org.apache.camel.quarkus.component.dataformats.json.model.TestPojo"/></unmarshal>
+ <to uri="mock:jackson-xml-unmarshal-list-reversePojo"/>
+ </route>
+
+ <route>
+ <from uri="direct:jackson-enablefeature-in"/>
+ <marshal><json library="Jackson"
unmarshalTypeName="org.apache.camel.quarkus.component.dataformats.json.model.TestPojo"
+ enableFeatures="WRAP_ROOT_VALUE"/></marshal>
+ </route>
</routes>
diff --git
a/integration-tests/dataformats-json/src/test/java/org/apache/camel/quarkus/component/dataformats/jackson/json/JacksonJsonIT.java
b/integration-tests/dataformats-json/src/test/java/org/apache/camel/quarkus/component/dataformats/jackson/json/JacksonJsonIT.java
new file mode 100644
index 0000000..7c60ad9
--- /dev/null
+++
b/integration-tests/dataformats-json/src/test/java/org/apache/camel/quarkus/component/dataformats/jackson/json/JacksonJsonIT.java
@@ -0,0 +1,24 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.quarkus.component.dataformats.jackson.json;
+
+import io.quarkus.test.junit.NativeImageTest;
+
+@NativeImageTest
+public class JacksonJsonIT extends JacksonJsonTest {
+
+}
diff --git
a/integration-tests/dataformats-json/src/test/java/org/apache/camel/quarkus/component/dataformats/jackson/json/JacksonJsonTest.java
b/integration-tests/dataformats-json/src/test/java/org/apache/camel/quarkus/component/dataformats/jackson/json/JacksonJsonTest.java
new file mode 100644
index 0000000..540b784
--- /dev/null
+++
b/integration-tests/dataformats-json/src/test/java/org/apache/camel/quarkus/component/dataformats/jackson/json/JacksonJsonTest.java
@@ -0,0 +1,233 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.quarkus.component.dataformats.jackson.json;
+
+import io.quarkus.test.junit.QuarkusTest;
+import io.restassured.RestAssured;
+import org.junit.jupiter.api.Test;
+
+import static org.hamcrest.Matchers.equalTo;
+
+@QuarkusTest
+public class JacksonJsonTest {
+ @Test
+ void jacksonUnmarshalTypeHeader() {
+ RestAssured.get("/dataformats-json/jackson/unmarshal-typeheader")
+ .then()
+ .statusCode(204);
+ }
+
+ @Test
+ void jacksonUnmarshalList() {
+ RestAssured.get("/dataformats-json/jackson/unmarshal-list")
+ .then()
+ .statusCode(204);
+ }
+
+ @Test
+ void jacksonUnmarshalListSplit() {
+
+ RestAssured.get("/dataformats-json/jackson/unmarshal-listsplit")
+ .then()
+ .statusCode(204);
+ }
+
+ @Test
+ void jacksonMarshalIncludeDefault() {
+ RestAssured.get("/dataformats-json/jackson/marshal-includedefault")
+ .then()
+ .statusCode(200)
+ .body(equalTo("{\"name\":\"Camel\",\"country\":null}"));
+ }
+
+ @Test
+ void jacksonUnmarshalArray() {
+
+ RestAssured.get("/dataformats-json/jackson/unmarshal-array")
+ .then()
+ .statusCode(204);
+ }
+
+ @Test
+ void jacksonMarshalContentTypeHeader() {
+ RestAssured.get("/dataformats-json/jackson/marshal-contenttype-header")
+ .then()
+ .statusCode(204);
+
+ }
+
+ @Test
+ void jacksonMarshalGeneral() {
+ RestAssured.get("/dataformats-json/jackson/marshal-general")
+ .then()
+ .statusCode(204);
+
+ }
+
+ @Test
+ void jacksonObjectMapperNoReg() {
+ RestAssured.get("/dataformats-json/jackson/object-mapper-noreg")
+ .then()
+ .statusCode(204);
+
+ }
+
+ @Test
+ void jacksonAllowJmsType() {
+ RestAssured.get("/dataformats-json/jackson/allowjmstype")
+ .then()
+ .statusCode(204);
+
+ }
+
+ @Test
+ void jacksonMarshalModule() {
+ RestAssured.get("/dataformats-json/jackson/marshal-module")
+ .then()
+ .statusCode(204);
+
+ }
+
+ @Test
+ void jacksonNotUseDefaultMapper() {
+ RestAssured.get("/dataformats-json/jackson/not-use-default-mapper")
+ .then()
+ .statusCode(204);
+
+ }
+
+ @Test
+ void jacksonUnmarshalListXmlConfigure() {
+
RestAssured.get("/dataformats-json/jackson/unmarshal-list-xml-configure")
+ .then()
+ .statusCode(204);
+
+ }
+
+ @Test
+ void jacksonObjectMapper() {
+ RestAssured.get("/dataformats-json/jackson/object-mapper")
+ .then()
+ .statusCode(204);
+
+ }
+
+ @Test
+ void jacksonPojoArray() {
+ RestAssured.get("/dataformats-json/jackson/pojo-array")
+ .then()
+ .statusCode(204);
+
+ }
+
+ @Test
+ void jacksonEnableFeature() {
+ RestAssured.get("/dataformats-json/jackson/enablefeature")
+ .then()
+ .statusCode(204);
+
+ }
+
+ @Test
+ void jacksonConcurrent() {
+ RestAssured.get("/dataformats-json/jackson/concurrent")
+ .then()
+ .statusCode(204);
+
+ }
+
+ @Test
+ void jacksonUnmarshalListJackson() {
+ RestAssured.get("/dataformats-json/jackson/unmarshal-listjackson")
+ .then()
+ .statusCode(204);
+
+ }
+
+ //@Test
+ void jacksonConversionPojo() {
+ RestAssured.get("/dataformats-json/jackson/conversion-pojo")
+ .then()
+ .statusCode(204);
+
+ }
+
+ @Test
+ void jacksonConversion() {
+ RestAssured.get("/dataformats-json/jackson/conversion")
+ .then()
+ .statusCode(204);
+
+ }
+
+ @Test
+ void jacksonConversionSimple() {
+ RestAssured.get("/dataformats-json/jackson/conversion-simple")
+ .then()
+ .statusCode(204);
+
+ }
+
+ //@Test
+ void jacksonJaxbAnnotation() {
+ RestAssured.get("/dataformats-json/jackson/jaxb-annotation")
+ .then()
+ .statusCode(204);
+
+ }
+
+ @Test
+ void jacksonView() {
+ RestAssured.get("/dataformats-json/jackson/view")
+ .then()
+ .statusCode(204);
+
+ }
+
+ @Test
+ void jacksonModuleRef() {
+ RestAssured.get("/dataformats-json/jackson/moduleref")
+ .then()
+ .statusCode(204);
+
+ }
+
+ @Test
+ void jacksonIncludeNoNull() {
+ RestAssured.get("/dataformats-json/jackson/include-no-null")
+ .then()
+ .statusCode(204);
+
+ }
+
+ @Test
+ void jacksonTypeHeaderNotAllowed() {
+ RestAssured.get("/dataformats-json/jackson/typeheader-not-allowed")
+ .then()
+ .statusCode(204);
+
+ }
+
+ @Test
+ void jacksonDateTimezone() {
+ RestAssured.get("/dataformats-json/jackson/datetimezone")
+ .then()
+ .statusCode(204);
+
+ }
+
+}
