Deserialisation to polymorphic class using JsonTypeInfo.Id.DEDUCTION and JacksonXmlElementWrapper annotation fails

[AlexiosP]

XML parsing fails when mapping to polymorphic class using JsonTypeInfo.Id.DEDUCTION and a property of the class is a flat list of elements where @JacksonXmlElementWrapper(useWrapping = false) is used.

Reproducable example in kotlin showcasing the issue

import com.fasterxml.jackson.annotation.JsonProperty
import com.fasterxml.jackson.annotation.JsonSubTypes
import com.fasterxml.jackson.annotation.JsonTypeInfo
import com.fasterxml.jackson.dataformat.xml.XmlMapper
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlElementWrapper
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty
import com.fasterxml.jackson.dataformat.xml.ser.ToXmlGenerator
import com.fasterxml.jackson.module.kotlin.KotlinFeature
import com.fasterxml.jackson.module.kotlin.KotlinModule
import org.junit.jupiter.api.Test

class XmlTest {

    private val somexml = """
    <?xml version="1.0" encoding="UTF-8"?>
    <RootTag>
        <Response>
            <SomeData>hello</SomeData>
            <Detail>
                <Text>hello world</Text>
            </Detail>
        </Response>
    </RootTag>
    """.trimIndent()

    @JsonTypeInfo(
        use = JsonTypeInfo.Id.DEDUCTION
    )
    @JsonSubTypes(
        JsonSubTypes.Type(value = Response.Success::class),
        JsonSubTypes.Type(value = Response.Error::class)
    )
    sealed class Response {
        data class Success(
            @JsonProperty("SomeData")
            val data: String,

            @JacksonXmlProperty(localName = "Detail")
            @JacksonXmlElementWrapper(useWrapping = false)
            val details: List<NestedClass>,
        ) : Response()

        data class Error(@JsonProperty("ErrCd") val errorCode: String) : Response()
    }

    data class NestedClass(@JsonProperty("Text") val text: String)
    data class WholeResponse(@JsonProperty("Response") val response: Response)
    data class WholeResponseWithoutDeduction(@JsonProperty("Response") val response: Response.Success)

    @Test
    fun `parse xml using deduction`() {
        // This test fails although it should pass
        ConfiguredXmlMapper.readValue(somexml, WholeResponse::class.java)
    }

    @Test
    fun `parse xml without using deduction`() {
        // This test passes which is normal
        ConfiguredXmlMapper.readValue(somexml, WholeResponseWithoutDeduction::class.java)
    }
}

object ConfiguredXmlMapper : XmlMapper() {
    init {
        registerModule(KotlinModule.Builder()
            .withReflectionCacheSize(512)
            .configure(KotlinFeature.NullToEmptyCollection, false)
            .configure(KotlinFeature.NullToEmptyMap, false)
            .configure(KotlinFeature.NullIsSameAsDefault, false)
            .configure(KotlinFeature.SingletonSupport, false)
            .configure(KotlinFeature.StrictNullChecks, false)
            .build())
    }
}

Using these related dependencies

dependencies {
    implementation("com.fasterxml.jackson.dataformat:jackson-dataformat-xml:2.13.2")
    implementation("com.fasterxml.jackson.module:jackson-module-jaxb-annotations:2.13.2")
    implementation("com.fasterxml.jackson.module:jackson-module-kotlin:2.13.1")
    implementation("com.fasterxml.jackson.module:jackson-modules-java8:2.13.2")
}

[cowtowncoder]

Ok; this either needs to move to Kotlin module (if Kotlin is required); or test changed to Java-only.

I suspect, however, that this combination of features (DEDUCTION and no-wrapping-for-Lists) can not actually be supported by Jackson.

[AlexiosP]

@cowtowncoder No problem, here is the test class written in Java

package com.example.showcasejacksonerror;

import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonSubTypes;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlElementWrapper;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;
import org.junit.jupiter.api.Test;

import java.util.List;

import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;

class ShowcaseJacksonErrorApplicationTests {

    @JsonTypeInfo(use = JsonTypeInfo.Id.DEDUCTION)
    @JsonSubTypes({
            @JsonSubTypes.Type(value = Success.class),
            @JsonSubTypes.Type(value = Error.class)
    })
    static abstract class Response {

    }

    static class Error extends Response {
        @JsonProperty("ErrCd")
        public String errorCode;

        public String getErrorCode() {
            return errorCode;
        }

        public void setErrorCode(String errorCode) {
            this.errorCode = errorCode;
        }
    }

    static class Success extends Response {
        @JsonProperty("SomeData")
        public String data;

        @JacksonXmlProperty(localName = "Detail")
        @JacksonXmlElementWrapper(useWrapping = false)
        public List<NestedClass> details;

        public String getData() {
            return data;
        }

        public void setData(String data) {
            this.data = data;
        }

        public List<NestedClass> getDetails() {
            return details;
        }

        public void setDetails(List<NestedClass> details) {
            this.details = details;
        }
    }

    static class NestedClass {
        @JsonProperty("Text")
        String text;

        public String getText() {
            return text;
        }

        public void setText(String text) {
            this.text = text;
        }
    }

    static class WholeResponse {
        @JsonProperty("Response")
        Response response;

        public Response getResponse() {
            return response;
        }

        public void setResponse(Response response) {
            this.response = response;
        }

    }

    static class WholeResponseWithoutDeduction {
        @JsonProperty("Response")
        Success response;

        public Success getResponse() {
            return response;
        }

        public void setResponse(Success response) {
            this.response = response;
        }

    }

    private XmlMapper xmlMapper = new XmlMapper();
    private String somexml = "<RootTag><Response><SomeData>hello</SomeData><Detail><Text>hello world</Text></Detail></Response></RootTag>";

    @Test
    public void parseXmlUsingDeduction() {
        // This test fails although it should pass
        assertDoesNotThrow(() -> xmlMapper.readValue(somexml, WholeResponse.class));
    }

}

with implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-xml:2.13.2' as dependency.

I don't know the limitations of Jackson, so can't comment on that. Theoretically it should be possible to my understanding, but if it is not feasible, you can close the issue I suppose.

[cowtowncoder]

Thank you!

Agreed: there is nothing theoretically preventing this from working, but I suspect that in practice the issue of "missing" wrapping prevents matching of specific properties here.
I will leave this open since it is a legitimate flaw at this point, in case someone has time and interest to look deeper into it.
(I am unlikely to have time to do so in near future)

[mmikhaylov]

Suppose, the same applies for any type of polymorphic mapping. We experience the same problem with @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.EXISTING_PROPERTY, property = "type"). This worked for sure for a while but then stopped to work (can't say exact version). The problem still exists in 2.15.3.

@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.EXISTING_PROPERTY, property = "type")
@JsonSubTypes({
    @Type(value = DateArrayValueConstant.class, name = "DATE"),
    @Type(value = IntegerArrayValueConstant.class, name = "INTEGER"),
    @Type(value = NumberArrayValueConstant.class, name = "NUMBER"),
    @Type(value = StringArrayValueConstant.class, name = "STRING"),
    @Type(value = TimeArrayValueConstant.class, name = "TIME"),
    @Type(value = TimestampArrayValueConstant.class, name = "TIMESTAMP")
})
public abstract class AbstractArrayValueConstant<X extends AbstractArrayValueConstant<X, V>, V>
    implements Serializable, ArrayValueConstant<V> {
    /**
     * GSVUID.
     */
    private static final long serialVersionUID = 1199956737222699976L;
    /**
     * The value
     */
    @JacksonXmlElementWrapper(useWrapping = true, localName = "values")
    @JacksonXmlProperty(localName = "value")
    protected ArrayList<V> values;
...

[cowtowncoder]

@mmikhaylov For other @JsonTypeInfo mechanisms, it is better to file separate issue and not add comment to DEDUCTION one -- DEDUCTION is rather special case. And if filing a new issue it'd be important to include full reproduction, not just a fragment.

But you are correct that support for @JsonTypeInfo by XML module is very limited.

Having said that, As.PROPERTY and As.EXISTING_PROPERTY are ones that do work to some degree (as opposed to As.WRAPPER_ARRAY, f.ex, which will not work).