Jackson Guava Optional<T> Deserialization

jackson_guava_optional.txt

Dependencies:
=============================================

compile "com.google.guava:guava:19.0"
compile 'com.fasterxml.jackson.datatype:jackson-datatype-guava:2.7.3'


Deserializer:
=============================================

public class OptionalLocaleStringDeserializer extends JsonDeserializer<Optional<String>> {

    @Override
    public Optional<String> deserialize(JsonParser jsonParser, DeserializationContext ctxt) throws IOException {
        final String stringToTranslate = jsonParser.getText();
        return Optional.fromNullable(LocaleHelper.getLocaleString(stringToTranslate));
    }
}


Test:
=============================================

public class OptionalDeserializationTest extends TestBase {

    private final static String SAMPLE_RESPONSE = "{\"null\":null,\"empty\":\"\",\"present\":\"hello\",\"locale\":\""
            + MockOptionalLocaleStringDeserializer.LOCALE_STRING_KEY + "\"}";

    private ObjectMapper mapper;
    private OptionalsTestObject testObject;

    @Before
    public void onSetup() throws IOException {
        mapper = new ObjectMapper();
        mapper.registerModule(new GuavaModule());
        testObject = mapper.readValue(SAMPLE_RESPONSE, OptionalsTestObject.class);
    }

    @Test
    public void testSerialization() throws JsonProcessingException {
        final ObjectMapper mapper = new ObjectMapper();
        mapper.setSerializationInclusion(JsonInclude.Include.NON_EMPTY);
        final String value = mapper.writeValueAsString(testObject);
        assertNotNull(value);
    }

    @Test
    public void testOptionalValueParcelling() {
        final Optional<String> stringBeforeParcel = testObject.getPresentString();

        final Parcel parcel = Parcel.obtain();
        testObject.writeToParcel(parcel, 0);
        parcel.setDataPosition(0);
        final OptionalsTestObject createdFromParcel =
                OptionalsTestObject.CREATOR.createFromParcel(parcel);

        final Optional<String> stringAfterParcel = createdFromParcel.getPresentString();
        assertEquals(stringBeforeParcel, stringAfterParcel);
    }

    @Test
    public void testOptionalFromMissingString() {
        final Optional<String> missingString = testObject.getMissingString();
        assertEquals(false, missingString.isPresent());
    }

    @Test
    public void testOptionalFromNullValue() {
        final Optional<String> nullString = testObject.getNullString();
        assertEquals(false, nullString.isPresent());
    }

    @Test
    public void testOptionalFromEmptyString() {
        final Optional<String> emptyString = testObject.getEmptyString();
        assertEquals(true, emptyString.isPresent()); // empty string will be present
    }

    @Test
    public void testOptionalFromPresentString() {
        final Optional<String> presentString = testObject.getPresentString();
        assertEquals(true, presentString.isPresent());
    }

    @Test
    public void testOptionalFromPresentLocaleString() {
        final Optional<String> localeString = testObject.getLocale();
        assertEquals(true, localeString.isPresent());
    }

    @Test
    public void testOptionalFromAbsentLocaleString() {
        final Optional<String> absentLocaleString = testObject.getAbsentLocale();
        assertEquals(false, absentLocaleString.isPresent());
    }
}


Test Model:
=============================================

public class OptionalsTestObject implements Parcelable {

    @JsonProperty("missing")
    private Optional<String> missingString = Optional.absent();

    @JsonProperty("null")
    private Optional<String> nullString = Optional.absent();

    @JsonProperty("empty")
    private Optional<String> emptyString = Optional.absent();

    @JsonProperty("present")
    private Optional<String> presentString = Optional.absent();

    @JsonProperty("locale")
    @JsonDeserialize(using = MockOptionalLocaleStringDeserializer.class)
    private Optional<String> locale = Optional.absent();

    @JsonProperty("absentLocale")
    @JsonDeserialize(using = MockOptionalLocaleStringDeserializer.class)
    private Optional<String> absentLocale = Optional.absent();

    public OptionalsTestObject() {
    }

    protected OptionalsTestObject(Parcel in) {
        missingString = Optional.fromNullable(in.readString());
        nullString = Optional.fromNullable(in.readString());
        emptyString = Optional.fromNullable(in.readString());
        presentString = Optional.fromNullable(in.readString());
        locale = Optional.fromNullable(in.readString());
        absentLocale = Optional.fromNullable(in.readString());
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(missingString.isPresent() ? missingString.get() : null);
        dest.writeString(nullString.isPresent() ? nullString.get() : null);
        dest.writeString(emptyString.isPresent() ? emptyString.get() : null);
        dest.writeString(presentString.isPresent() ? presentString.get() : null);
        dest.writeString(locale.isPresent() ? locale.get() : null);
        dest.writeString(absentLocale.isPresent() ? absentLocale.get() : null);
    }

    public static final Creator<OptionalsTestObject> CREATOR = new Creator<OptionalsTestObject>() {
        @Override
        public OptionalsTestObject createFromParcel(Parcel in) {
            return new OptionalsTestObject(in);
        }

        @Override
        public OptionalsTestObject[] newArray(int size) {
            return new OptionalsTestObject[size];
        }
    };

    public Optional<String> getMissingString() {
        return missingString;
    }

    public Optional<String> getNullString() {
        return nullString;
    }

    public Optional<String> getEmptyString() {
        return emptyString;
    }

    public Optional<String> getPresentString() {
        return presentString;
    }

    public Optional<String> getLocale() {
        return locale;
    }

    public Optional<String> getAbsentLocale() {
        return absentLocale;
    }

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        OptionalsTestObject that = (OptionalsTestObject) o;

        if (missingString != null ? !missingString.equals(that.missingString) : that.missingString != null)
            return false;
        if (nullString != null ? !nullString.equals(that.nullString) : that.nullString != null)
            return false;
        if (emptyString != null ? !emptyString.equals(that.emptyString) : that.emptyString != null)
            return false;
        if (presentString != null ? !presentString.equals(that.presentString) : that.presentString != null)
            return false;
        if (locale != null ? !locale.equals(that.locale) : that.locale != null) return false;
        return absentLocale != null ? absentLocale.equals(that.absentLocale) : that.absentLocale == null;

    }

    @Override
    public int hashCode() {
        int result = missingString != null ? missingString.hashCode() : 0;
        result = 31 * result + (nullString != null ? nullString.hashCode() : 0);
        result = 31 * result + (emptyString != null ? emptyString.hashCode() : 0);
        result = 31 * result + (presentString != null ? presentString.hashCode() : 0);
        result = 31 * result + (locale != null ? locale.hashCode() : 0);
        result = 31 * result + (absentLocale != null ? absentLocale.hashCode() : 0);
        return result;
    }
}