Spring's bean property access and conversion tests.

gistfile1.java

package com.github.ryoasai;

import java.util.Date;

import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;

import org.joda.time.DateMidnight;
import org.springframework.format.annotation.DateTimeFormat;

public class Person {

    @NotNull
    private String name;

    private int age;

    @DateTimeFormat(pattern = "yyyy-MM-dd")
    private Date birthDate;

    public Person() {
        this("test", 30, new DateMidnight(2010, 5, 2).toDate());
    }

    public Person(String name, int age, Date birthDate) {
        this.name = name;
        this.age = age;
        this.birthDate = birthDate;
    }

    @Size(max = 15)
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Date getBirthDate() {
        return birthDate;
    }

    public void setBirthDate(Date birthDate) {
        this.birthDate = birthDate;
    }

}

//=============================================================================

package com.github.ryoasai;

import static org.hamcrest.CoreMatchers.*;
import static org.junit.Assert.*;

import java.util.Arrays;
import java.util.Date;
import java.util.List;

import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;

import org.hamcrest.Matcher;
import org.joda.time.DateMidnight;
import org.junit.Before;
import org.junit.Test;
import org.springframework.beans.BeanWrapper;
import org.springframework.beans.ConfigurablePropertyAccessor;
import org.springframework.beans.PropertyAccessorFactory;
import org.springframework.core.convert.TypeDescriptor;
import org.springframework.format.support.FormattingConversionService;
import org.springframework.format.support.FormattingConversionServiceFactoryBean;
import org.springframework.util.ReflectionUtils;

public class SpringBeanUtilsTest {

    FormattingConversionService conversionService; 
    Person person = new Person("test", 30, new DateMidnight(2010, 5, 2).toDate());

    public static Matcher<Class<?>> isSameClassAs(Class<?> clazz) {
        @SuppressWarnings("unchecked")
        Matcher<Class<?>> result = (Matcher<Class<?>>) (Matcher<?>) is((Object) clazz);

        return result;
    }
    
    @Before
    public void setUp() {
        FormattingConversionServiceFactoryBean factoryBean = new FormattingConversionServiceFactoryBean();
        factoryBean.afterPropertiesSet();
        conversionService = factoryBean.getObject();
    }
    
    //=============================================================
    // Bean properties and fields access.
    //=============================================================
    
    @Test
    public void beanPropertyAccess() {
        BeanWrapper beanWrapper = PropertyAccessorFactory.forBeanPropertyAccess(person);

        // property value
        assertThat((String) beanWrapper.getPropertyValue("name"), is("test"));
        // property type(Class)
        assertThat(beanWrapper.getPropertyType("name"), isSameClassAs(String.class));

        // property type(TypeDescriptor)
        TypeDescriptor typeDesc = beanWrapper.getPropertyTypeDescriptor("name");
        assertThat(typeDesc.getType(), isSameClassAs(String.class));

        // Annotations on property
        // Annotations may be attached on either field or getter.
        assertThat(typeDesc.getAnnotation(NotNull.class), is(NotNull.class));
        assertThat(typeDesc.getAnnotation(Size.class), is(Size.class));
    }

    @Test
    public void beanDirectFieldAccess() {
        ConfigurablePropertyAccessor fieldAccessor = PropertyAccessorFactory.forDirectFieldAccess(person);

        // field value
        assertThat((String) fieldAccessor.getPropertyValue("name"), is("test"));
        // field type (Class)
        assertThat(fieldAccessor.getPropertyType("name"), isSameClassAs(String.class));

        // field type(TypeDescriptor)
        TypeDescriptor typeDesc = fieldAccessor.getPropertyTypeDescriptor("name");
        assertThat(typeDesc.getType(), isSameClassAs(String.class));

        // Annotations on field.
        // Annotations may be attached only on field.
        assertThat(typeDesc.getAnnotation(NotNull.class), is(NotNull.class));
        assertThat(typeDesc.getAnnotation(Size.class), is(nullValue()));
    }
    
    //=============================================================
    // Conversion
    //=============================================================
    
    @Test
    public void basicConversion() {
        // String -＞ Integer 
        assertThat(conversionService.convert("123", Integer.class), is(123));

        // Integer -＞ String 
        assertThat(conversionService.convert(123, String.class), is("123"));

        // String -＞ Boolean 
        assertThat(conversionService.convert("true", Boolean.class), is(true));

        // Boolean -＞ String 
        assertThat(conversionService.convert(true, String.class), is("true"));
    }
    
    public static enum TestEnum {
        ITEM1, ITEM2
    }

    @Test
    public void enumConversion() {
        // String -＞ enum 
        assertThat(conversionService.convert("ITEM1", TestEnum.class), is(TestEnum.ITEM1));

        // enum -＞ String 
        assertThat(conversionService.convert(TestEnum.ITEM1, String.class), is("ITEM1"));
    }

    List<String> strList = Arrays.asList("1", "2", "3");
    List<Integer> intList = Arrays.asList(1, 2, 3);

    @SuppressWarnings("unchecked")
    @Test
    public void collectionConversion() {
        
        TypeDescriptor strListTypeDesc = new TypeDescriptor(ReflectionUtils.findField(getClass(), "strList"));
        TypeDescriptor intListTypeDesc = new TypeDescriptor(ReflectionUtils.findField(getClass(), "intList"));
        
        // List<String> -＞ List<Integer> 
        assertThat((List<Integer>)conversionService.convert(strList, strListTypeDesc, intListTypeDesc), is(intList));

        // List<String> -＞ List<Integer> 
        assertThat((List<String>)conversionService.convert(intList, intListTypeDesc, strListTypeDesc), is(strList));
    }

    String[] strArray = {"1", "2", "3"};
    int[] intArray = {1, 2, 3};

    @Test
    public void arrayConversion() {
        
        TypeDescriptor strArrayTypeDesc = new TypeDescriptor(ReflectionUtils.findField(getClass(), "strArray"));
        TypeDescriptor intArrayTypeDesc = new TypeDescriptor(ReflectionUtils.findField(getClass(), "intArray"));
        
        // String[] -＞ Integer[] 
        assertArrayEquals(intArray, (int[])conversionService.convert(strArray, strArrayTypeDesc, intArrayTypeDesc));

        // Integer[] -＞ String[] 
        assertArrayEquals(strArray, (String[])conversionService.convert(intArray, intArrayTypeDesc, strArrayTypeDesc));
    }
    
    //=============================================================
    // Format(Printing and parsing)
    //=============================================================
    
    @Test
    public void dateFormat() {
        BeanWrapper beanWrapper = PropertyAccessorFactory.forBeanPropertyAccess(person);
        
        TypeDescriptor fieldDesc = beanWrapper.getPropertyTypeDescriptor("birthDate");
        TypeDescriptor strDesc = TypeDescriptor.valueOf(String.class);

        // Date -> String
        String formattedValue = (String)conversionService.convert(beanWrapper.getPropertyValue("birthDate"), fieldDesc, strDesc);
        assertThat(formattedValue, is("2010-05-02"));

        // String -> Date
        Date parsedValue = (Date)conversionService.convert("2010-05-02", strDesc, fieldDesc);
        assertThat(parsedValue, is(person.getBirthDate()));
    }

    
    //=============================================================
    // SpEL
    //=============================================================
    

    @Test
    public void spEL() {
        ExpressionParser parser = new SpelExpressionParser();
        Expression exp = parser.parseExpression("name = #{name}, age = #{age}, bitdhDate = #{birthDate}", new TemplateParserContext());

        StandardEvaluationContext evaluationContext = new StandardEvaluationContext();
        StandardTypeConverter converter = new StandardTypeConverter(conversionService);
        evaluationContext.setTypeConverter(converter);
        
        String value = exp.getValue(evaluationContext, new Person(), String.class);
        
        assertThat(value , is("name = test, age = 30, bitdhDate = 2010-05-02"));
    }
}