private static void CompareFieldValues(IEquivalencyValidationContext context, IEquivalencyValidator parent,
DataRow subject, DataRow expectation, DataEquivalencyAssertionOptions <DataSet> dataSetConfig,
DataEquivalencyAssertionOptions <DataTable> dataTableConfig, DataEquivalencyAssertionOptions <DataRow> dataRowConfig)
{
IEnumerable <string> expectationColumnNames = expectation.Table.Columns.OfType <DataColumn>()
.Select(col => col.ColumnName);
IEnumerable <string> subjectColumnNames = subject.Table.Columns.OfType <DataColumn>()
.Select(col => col.ColumnName);
bool ignoreUnmatchedColumns =
(dataSetConfig?.IgnoreUnmatchedColumns == true) ||
(dataTableConfig?.IgnoreUnmatchedColumns == true) ||
(dataRowConfig?.IgnoreUnmatchedColumns == true);
DataRowVersion subjectVersion =
(subject.RowState == DataRowState.Deleted)
? DataRowVersion.Original
: DataRowVersion.Current;
DataRowVersion expectationVersion =
(expectation.RowState == DataRowState.Deleted)
? DataRowVersion.Original
: DataRowVersion.Current;
bool compareOriginalVersions =
(subject.RowState == DataRowState.Modified) && (expectation.RowState == DataRowState.Modified);
if ((dataSetConfig?.ExcludeOriginalData == true) ||
(dataTableConfig?.ExcludeOriginalData == true) ||
(dataRowConfig?.ExcludeOriginalData == true))
{
compareOriginalVersions = false;
}
foreach (var columnName in expectationColumnNames.Union(subjectColumnNames))
{
DataColumn expectationColumn = expectation.Table.Columns[columnName];
DataColumn subjectColumn = subject.Table.Columns[columnName];
if (subjectColumn is not null &&
((dataSetConfig?.ShouldExcludeColumn(subjectColumn) == true) ||
(dataTableConfig?.ShouldExcludeColumn(subjectColumn) == true) ||
(dataRowConfig?.ShouldExcludeColumn(subjectColumn) == true)))
{
continue;
}
if (!ignoreUnmatchedColumns)
{
AssertionScope.Current
.ForCondition(subjectColumn is not null)
.FailWith("Expected {context:DataRow} to have column '{0}'{reason}, but found none", columnName);
AssertionScope.Current
.ForCondition(expectationColumn is not null)
.FailWith("Found unexpected column '{0}' in {context:DataRow}", columnName);
}
if ((subjectColumn is not null) && (expectationColumn is not null))
{
CompareFieldValue(context, parent, subject, expectation, subjectColumn, subjectVersion, expectationColumn,
expectationVersion);
if (compareOriginalVersions)
{
CompareFieldValue(context, parent, subject, expectation, subjectColumn, DataRowVersion.Original,
expectationColumn, DataRowVersion.Original);
}
}
}
}
private static void CompareCollections(IEquivalencyValidationContext context, IEquivalencyValidator parent, IEquivalencyAssertionOptions config, DataSet subject, DataSet expectation, DataEquivalencyAssertionOptions <DataSet> dataConfig, Dictionary <string, IMember> selectedMembers)
{
// Note: The collections here are listed in the XML documentation for the DataSet.BeEquivalentTo extension
// method in DataSetAssertions.cs. If this ever needs to change, keep them in sync.
CompareExtendedProperties(new Comparands(subject, expectation, typeof(DataSet)), context, parent, config, selectedMembers);
CompareTables(context, parent, subject, expectation, dataConfig, selectedMembers);
}
private static void CompareTables(IEquivalencyValidationContext context, IEquivalencyValidator parent, DataSet subject, DataSet expectation, DataEquivalencyAssertionOptions <DataSet> dataConfig, Dictionary <string, IMember> selectedMembers)
{
if (selectedMembers.ContainsKey(nameof(expectation.Tables)))
{
bool success = AssertionScope.Current
.ForCondition(subject.Tables.Count == expectation.Tables.Count)
.FailWith("Expected {context:DataSet} to contain {0}, but found {1} table(s)", expectation.Tables.Count, subject.Tables.Count);
if (!success)
{
return;
}
if (dataConfig is not null)
{
bool excludeCaseSensitive = !selectedMembers.ContainsKey(nameof(DataSet.CaseSensitive));
bool excludeLocale = !selectedMembers.ContainsKey(nameof(DataSet.Locale));
if (excludeCaseSensitive || excludeLocale)
{
dataConfig.Excluding((IMemberInfo memberInfo) =>
(memberInfo.DeclaringType == typeof(DataTable)) &&
(
(excludeCaseSensitive && (memberInfo.Name == nameof(DataTable.CaseSensitive)))
||
(excludeLocale && (memberInfo.Name == nameof(DataTable.Locale)))));
}
}
IEnumerable <string> expectationTableNames = expectation.Tables.OfType <DataTable>()
.Select(table => table.TableName);
IEnumerable <string> subjectTableNames = subject.Tables.OfType <DataTable>()
.Select(table => table.TableName);
foreach (string tableName in expectationTableNames.Union(subjectTableNames))
{
if (dataConfig?.ExcludeTableNames.Contains(tableName) == true)
{
continue;
}
CompareTable(context, parent, subject, expectation, tableName);
}
}
}
public ColumnNamesByTableNameAdapter(DataEquivalencyAssertionOptions <T> owner)
{
this.owner = owner;
}
