DefaultFailureHandler.java
/*
*
* The DbUnit Database Testing Framework
* Copyright (C)2002-2008, DbUnit.org
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
package org.dbunit.assertion;
import java.util.Arrays;
import org.dbunit.dataset.Column;
import org.dbunit.dataset.ColumnFilterTable;
import org.dbunit.dataset.Columns;
import org.dbunit.dataset.DataSetException;
import org.dbunit.dataset.ITable;
import org.dbunit.dataset.ITableMetaData;
import org.dbunit.dataset.NoSuchColumnException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Default implementation of the {@link FailureHandler}.
*
* @author gommma (gommma AT users.sourceforge.net)
* @since 2.4.0
*/
public class DefaultFailureHandler implements FailureHandler
{
private static final Logger logger =
LoggerFactory.getLogger(DefaultFailureHandler.class);
private String[] _additionalColumnInfo;
private FailureFactory failureFactory = new DefaultFailureFactory();
/**
* Default constructor which does not provide any additional column
* information.
*/
public DefaultFailureHandler()
{
}
/**
* Create a default failure handler
*
* @param additionalColumnInfo
* the column names of the columns for which additional
* information should be printed when an assertion failed.
*/
public DefaultFailureHandler(final Column[] additionalColumnInfo)
{
// Null-safe access
if (additionalColumnInfo != null)
{
this._additionalColumnInfo =
Columns.getColumnNames(additionalColumnInfo);
}
}
/**
* Create a default failure handler
*
* @param additionalColumnInfo
* the column names of the columns for which additional
* information should be printed when an assertion failed.
*/
public DefaultFailureHandler(final String[] additionalColumnInfo)
{
this._additionalColumnInfo = additionalColumnInfo;
}
/**
* @param failureFactory
* The {@link FailureFactory} to be used for creating assertion
* errors.
*/
public void setFailureFactory(final FailureFactory failureFactory)
{
if (failureFactory == null)
{
throw new NullPointerException(
"The parameter 'failureFactory' must not be null");
}
this.failureFactory = failureFactory;
}
public Error createFailure(final String message, final String expected,
final String actual)
{
return this.failureFactory.createFailure(message, expected, actual);
}
public Error createFailure(final String message)
{
return this.failureFactory.createFailure(message);
}
public String getAdditionalInfo(final ITable expectedTable,
final ITable actualTable, final int row, final String columnName)
{
// add custom column values information for better identification of
// mismatching rows
return buildAdditionalColumnInfo(expectedTable, actualTable, row);
}
private String buildAdditionalColumnInfo(final ITable expectedTable,
final ITable actualTable, final int rowIndex)
{
if (logger.isDebugEnabled())
{
logger.debug(
"buildAdditionalColumnInfo(expectedTable={}, actualTable={}, rowIndex={}, "
+ "additionalColumnInfo={}) - start",
expectedTable, actualTable,
rowIndex, _additionalColumnInfo);
}
// No columns specified
if (_additionalColumnInfo == null || _additionalColumnInfo.length <= 0)
{
return null;
}
final StringBuilder sb = new StringBuilder();
sb.append("Additional row info:");
for (int j = 0; j < _additionalColumnInfo.length; j++)
{
final String columnName = _additionalColumnInfo[j];
final Object expectedKeyValue =
getColumnValue(expectedTable, rowIndex, columnName);
final Object actualKeyValue =
getColumnValue(actualTable, rowIndex, columnName);
sb.append(" ('");
sb.append(columnName);
sb.append("': expected=<");
sb.append(expectedKeyValue);
sb.append(">, actual=<");
sb.append(actualKeyValue);
sb.append(">)");
}
return sb.toString();
}
protected Object getColumnValue(final ITable table, final int rowIndex,
final String columnName)
{
Object value = null;
try
{
// Get the ITable object to be used for showing the column values
// (needed in case of Filtered tables)
final ITable tableForCol = getTableForColumn(table, columnName);
value = tableForCol.getValue(rowIndex, columnName);
} catch (final DataSetException e)
{
value = makeAdditionalColumnInfoErrorMessage(columnName, e);
}
return value;
}
protected String makeAdditionalColumnInfoErrorMessage(
final String columnName, final DataSetException e)
{
final StringBuilder sb = new StringBuilder();
sb.append("Exception creating more info for column '");
sb.append(columnName);
sb.append("': ");
sb.append(e.getClass().getName());
sb.append(": ");
sb.append(e.getMessage());
final String msg = sb.toString();
logger.warn(msg, e);
return " (!!!!! " + msg + ")";
}
/**
* @param table
* The table which might be a decorated table
* @param columnName
* The column name for which a table is searched
* @return The table that as a column with the given name
* @throws DataSetException
* If no table could be found having a column with the given
* name
*/
private ITable getTableForColumn(final ITable table,
final String columnName) throws DataSetException
{
final ITableMetaData tableMetaData = table.getTableMetaData();
try
{
tableMetaData.getColumnIndex(columnName);
// if the column index was resolved the table contains the given
// column. So just use this table
return table;
} catch (final NoSuchColumnException e)
{
// If the column was not found check for filtered table
if (table instanceof ColumnFilterTable)
{
final ITableMetaData originalMetaData =
((ColumnFilterTable) table).getOriginalMetaData();
originalMetaData.getColumnIndex(columnName);
// If we get here the column exists - return the table since it
// is not filtered in the CompositeTable.
return table;
} else
{
// Column not available in the table - rethrow the exception
throw e;
}
}
}
public void handle(final Difference diff)
{
final String msg = buildMessage(diff);
final Error err =
this.createFailure(msg, String.valueOf(diff.getExpectedValue()),
String.valueOf(diff.getActualValue()));
// Throw the assertion error
throw err;
}
protected String buildMessage(final Difference diff)
{
final StringBuilder builder = new StringBuilder(200);
final int rowNum = diff.getRowIndex();
final String columnName = diff.getColumnName();
final ITable expectedTable = diff.getExpectedTable();
final ITable actualTable = diff.getActualTable();
addFailMessage(diff, builder);
final String expectedTableName =
expectedTable.getTableMetaData().getTableName();
// example message:
// "value (table=MYTAB, row=232, column=MYCOL, Additional row info:
// (column=MyIdCol, expected=444, actual=555)): expected:<123> but
// was:<1234>"
builder.append("value (table=").append(expectedTableName);
builder.append(", row=").append(rowNum);
builder.append(", col=").append(columnName);
final String additionalInfo = this.getAdditionalInfo(expectedTable,
actualTable, rowNum, columnName);
if (additionalInfo != null && !additionalInfo.trim().equals(""))
{
builder.append(", ").append(additionalInfo);
}
builder.append(")");
return builder.toString();
}
protected void addFailMessage(final Difference diff,
final StringBuilder builder)
{
final String failMessage = diff.getFailMessage();
final boolean isFailMessage = isFailMessage(failMessage);
if (isFailMessage)
{
builder.append(failMessage).append(": ");
}
}
protected boolean isFailMessage(final String failMessage)
{
return failMessage != null && !failMessage.isEmpty();
}
@Override
public String toString()
{
final StringBuilder sb = new StringBuilder();
sb.append(DefaultFailureHandler.class.getName()).append("[");
sb.append("_additionalColumnInfo=").append(_additionalColumnInfo == null
? "null" : Arrays.asList(_additionalColumnInfo).toString());
sb.append("]");
return sb.toString();
}
/**
* Default failure factory which returns DBUnits own assertion error
* instances.
*
* @author gommma (gommma AT users.sourceforge.net)
* @author Last changed by: $Author: gommma $
* @version $Revision: 872 $ $Date: 2008-11-08 09:45:52 -0600 (Sat, 08 Nov
* 2008) $
* @since 2.4.0
*/
public static class DefaultFailureFactory implements FailureFactory
{
public Error createFailure(final String message, final String expected,
final String actual)
{
// Return dbunit's own comparison failure object
return new DbComparisonFailure(message, expected, actual);
}
public Error createFailure(final String message)
{
// Return dbunit's own failure object
return new DbAssertionFailedError(message);
}
}
}