basebotestcase.java

A Java web application, based on Struts and Hibernate, that serves as an online running log. Users m

package net.sf.irunninglog.businessobject;

import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;

import net.sf.irunninglog.junit.BaseTestCase;
import net.sf.irunninglog.util.ConstantValues;
import net.sf.irunninglog.util.ConversionException;
import net.sf.irunninglog.util.Conversions;
import net.sf.irunninglog.util.DTO;
import net.sf.irunninglog.util.FatalRuntimeException;
import net.sf.irunninglog.util.Utilities;
import net.sf.irunninglog.validation.ValidationException;

public abstract class BaseBOTestCase extends BaseTestCase {

    protected BaseBO bo;

    public BaseBOTestCase(String name) {
        super(name);
    }

    // JUNIT METHODS

    public void setUp() {
        try {
            bo =  (BaseBO) BusinessObjectFactory.newInstance(getBOType());
        } catch (Exception ex) {
            throw new FatalRuntimeException(ex);
        }
    }

    public void testFields() {}

    protected void executeStringFieldTests(String fieldName) {
        Object [] objs = new Object[] {null, ConstantValues.STRING_BLANK, STRING_FOO};

        Object [] results = executeFieldTests(fieldName, String.class, objs);

        for (int i=0; i<objs.length; i++) {
            assertEquals(objs[i], results[i]);
        }
    }

    protected void executeDecimalFieldTests(String fieldName) {
        Object [] objs = new Object [] {null, ConstantValues.BD_ZERO};

        Object [] results = executeFieldTests(fieldName, BigDecimal.class, objs);

        for (int i=0; i<objs.length; i++) {
            assertEquals(objs[i], results[i]);
        }
    }

    protected void executeLongFieldTests(String fieldName) {
        Object [] objs = new Object [] {null, new Long(0)};

        Object [] results = executeFieldTests(fieldName, Long.class, objs);

        for (int i=0; i<objs.length; i++) {
            assertEquals(objs[i], results[i]);
        }
    }

    protected void executeBooleanFieldTests(String fieldName) {
        Object [] objs = new Object [] {Boolean.TRUE, Boolean.FALSE};

        Object [] results = executeFieldTests(fieldName, Boolean.class, objs);

        for (int i=0; i<objs.length; i++) {
            assertEquals(objs[i], results[i]);
        }
    }

    protected void executeDateFieldTests(String fieldName) {
        Object [] objs = new Object [] {null, new Date()};

        Object [] results = executeFieldTests(fieldName, Date.class, objs);

        for (int i=0; i<objs.length; i++) {
            assertEquals(objs[i], results[i]);
        }
    }

    private Object [] executeFieldTests(String fieldName, Class fieldClass, Object [] params) {
        try {
            Object [] results = new Object[params.length];

            String first = fieldName.substring(0, 1).toUpperCase();
            fieldName = first + fieldName.substring(1, fieldName.length());
            Method getter = findGetter(fieldName, fieldClass);
            Method setter = findSetter(fieldName, fieldClass);

            assertNotNull(getter);
            assertNotNull(setter);

            for (int i = 0; i < params.length; i++) {
                setter.invoke(bo, new Object[] {params[i]});
                results[i] = getter.invoke(bo, null);
            }

            return results;
        } catch (Exception ex) {
            LOG.fatal("Unable to perform field tests ", ex);
            failTest();
            return null;
        }
    }

    public void testGetValues() {
        DTO values = bo.getValues();
        assertNotNull(values);
        assertNotNull(values.getCanonicalId());
        assertEquals(getDTOCanonicalId(), values.getCanonicalId());
    }

    public void testGetValuesInternal() {
        DTO values = bo.getValuesInternal();
        assertNotNull(values);
        assertNotNull(values.getCanonicalId());
        assertEquals(getDTOCanonicalId(), values.getCanonicalId());
    }

    public void testSetValues() { }

    protected void executeSetValuesTests(String fieldName, String [] validValues, String [] invalidValues) {
        DTO values = getValidDTO();

        try {
            bo.setValues(null);
            failTest();
        } catch (NullPointerException ex) {
            assertTrue(true);
        } catch (Throwable ex) {
            LOG.error("Test Failed", ex);
            failTest();
        }

        try {
            bo.setValues(values);
        } catch (Throwable ex) {
            LOG.fatal("Test Failed " + values, ex);
            failTest();
        }

        for (int i=0; i<validValues.length;i++) {
            values = getValidDTO();
            values.setValue(fieldName, validValues[i]);
            try {
                bo.setValues(values);
            } catch (Throwable ex) {
                LOG.fatal("Test Failed for "+fieldName+"/"+validValues[i], ex);
                failTest();
            }
        }

        for (int i=0; i<invalidValues.length; i++) {
            values = getValidDTO();
            values.setValue(fieldName, invalidValues[i]);
            try {
                bo.setValues(values);
                failTest();
            } catch (ValidationException ex) {
                assertNotNull(ex.getErrors());
                assertTrue(ex.getErrors().size() > 0);
            }catch (Throwable ex) {
                LOG.fatal("Test Failed for "+fieldName+"/"+invalidValues[i], ex);
                failTest();
            }
        }
    }

    public void testSetValuesInternal() { }

    protected void executeSetValuesInternalTests(String fieldName, Class fieldClass, String [] validValues, String [] invalidValues) {
        DTO values = getValidDTO();
        DTO output = null;
        Method getter = null;

        try {
            getter = findGetter(fieldName, fieldClass);
            bo.setValuesInternal(null);
            failTest();
        } catch (NullPointerException ex) {
            assertTrue(true);
        } catch (Throwable ex) {
            LOG.fatal("Test Failed", ex);
            failTest();
        }

        try {
            bo.setValuesInternal(values);
        } catch (Throwable ex) {
            LOG.error("Test Failed", ex);
            failTest();
        }

        for (int i=0; i<validValues.length;i++) {
            values = getValidDTO();
            values.setValue(fieldName, validValues[i]);
            String expected = Utilities.isBlank(validValues[i]) ? null : validValues[i];
            try {
                bo.setValuesInternal(values);
                output = bo.getValues();
                if (expected != null && fieldClass == Boolean.class) {
                    expected = Conversions.stringToBoolean(expected).toString();
                }else if (expected != null && fieldClass == Date.class) {
                    Date date = Conversions.stringToDate(expected);
                    expected = Conversions.dateToString(date);
                }else if (expected != null && fieldClass == BigDecimal.class) {
                    BigDecimal dec = Conversions.stringToDecimal(expected);
                    expected = Conversions.decimalToString(dec);
                }else if (expected != null && fieldClass == Long.class) {
                    Long l = Conversions.stringToTime(expected);
                    expected = Conversions.timeToString(l);
                } else if (expected == null && fieldClass == Boolean.TYPE) {
                    expected = ConstantValues.STRING_FALSE;
                }

                assertEquals(expected, output.getValue(fieldName));
                if (fieldClass == Boolean.class) {
                    assertEquals(Conversions.stringToBoolean(expected), (Boolean) getter.invoke(bo, null));
                } else if (fieldClass == BigDecimal.class) {
                    assertEquals(Conversions.stringToDecimal(expected), (BigDecimal) getter.invoke(bo, null));
                } else if (fieldClass == Date.class) {
                    assertEquals(Conversions.stringToDate(expected), (Date) getter.invoke(bo, null));
                } else if (fieldClass == Long.class) {
                    assertEquals(Conversions.stringToTime(expected), (Long) getter.invoke(bo, null));
                } else {
                    assertEquals(expected, getter.invoke(bo, null));
                }
            } catch (Throwable ex) {
                LOG.fatal("Test Failed ", ex);
                LOG.fatal("Test Failed " + " " + validValues[i] + " " + expected + " " + output.getValue(fieldName));
                failTest();
            }
        }

        for (int i=0; i<invalidValues.length; i++) {
            values = getValidDTO();
            values.setValue(fieldName, invalidValues[i]);
            try {
                bo.setValuesInternal(values);
                failTest();
            } catch (ConversionException ex) {
                assertTrue(true);
            } catch (Throwable ex) {
                LOG.fatal("Test Failed " +fieldName+"/"+invalidValues[i], ex);
                failTest();
            }
        }
    }

    public void testValidateValues() { }

    protected void executeValidateValuesTests(String fieldName, String [] validValues, String [] invalidValues) {
        DTO values = getValidDTO();
        List errors = null;

        try {
            bo.validateValues(null);
            failTest();
        } catch (IllegalArgumentException ex) {
            assertTrue(true);
        } catch (Throwable ex) {
            failTest();
        }

        errors = bo.validateValues(values);
        assertNotNull(errors);
        assertEquals(0, errors.size());

        for (int i=0; i<validValues.length;i++) {
            values = getValidDTO();
            values.setValue(fieldName, validValues[i]);
            errors = bo.validateValues(values);
            assertNotNull(errors);
            assertEquals(0, errors.size());
        }

        for (int i=0; i<invalidValues.length;i++) {
            values = getValidDTO();
            values.setValue(fieldName, invalidValues[i]);
            errors = bo.validateValues(values);
            assertNotNull(errors);
            assertTrue(errors.size() > 0);
        }
    }

    public void testDefaultValues() { }

    protected void executeDefaultValuesTests(String fieldName, String expected) {
        DTO values = getNewDTO();

        try {
            bo.defaultValues(null);
        } catch (NullPointerException ex) {
            // Don't care about this
            assertTrue(true);
        } catch (Throwable ex) {
            LOG.error("Test Failed", ex);
            failTest();
        }

        values.setValue(fieldName, null);
        bo.defaultValues(values);
        assertEquals(expected, values.getValue(fieldName));

        values.setValue(fieldName, ConstantValues.STRING_BLANK);
        bo.defaultValues(values);
        assertEquals(expected, values.getValue(fieldName));

        values.setValue(fieldName, STRING_FOO);
        bo.defaultValues(values);
        assertEquals(STRING_FOO, values.getValue(fieldName));
    }

    public void testPrimaryKey() { }

    // UTILITY METHODS

    protected abstract String getBOType();

    protected DTO getNewDTO() {
        return new DTO(getDTOCanonicalId());
    }

    protected abstract DTO getValidDTO();

    protected abstract String getDTOCanonicalId();

    private Method findGetter(String fieldName, Class clazz) throws Exception {
        Method getter = null;
        String first = fieldName.substring(0, 1).toUpperCase();
        fieldName = first + fieldName.substring(1, fieldName.length());

        if (clazz == (Boolean.class)) {
            getter = bo.getClass().getMethod("is" + fieldName, null);
        } else {
            getter = bo.getClass().getMethod("get" + fieldName, null);
        }
        return getter;
    }

    private Method findSetter(String fieldName, Class clazz) throws Exception {
        Method setter = null;
        String first = fieldName.substring(0, 1).toUpperCase();
        fieldName = first + fieldName.substring(1, fieldName.length());

        return bo.getClass().getMethod("set" + fieldName, new Class[] {clazz});
    }

}