public void CellReader_SetNull_ThrowsArgumentNullException()
{
var reader = new ColumnNameValueReader("Column");
var map = new SubOneToOneMap <int>(reader);
Assert.Throws <ArgumentNullException>("value", () => map.CellReader = null);
}
public void Ctor_InnerReader()
{
var innerReader = new ColumnNameValueReader("ColumnName");
var reader = new OptionalCellValueReader(innerReader);
Assert.Same(innerReader, reader.InnerReader);
}
public void AddCellValueTransformer_NullTransformer_ThrowsArgumentNullException()
{
var reader = new ColumnNameValueReader("Column");
var map = new SubOneToOneMap <int>(reader);
Assert.Throws <ArgumentNullException>("transformer", () => map.AddCellValueTransformer(null));
}
/// <summary>
/// Constructs a map reads one or more values from one or more cells and maps these values as element
/// contained by the property or field.
/// </summary>
/// <param name="member">The property or field to map the values of one or more cell to.</param>
/// <param name="elementMapping">The map that maps the value of a single cell to an object of the element type of the property or field.</param>
protected EnumerableExcelPropertyMap(MemberInfo member, SingleExcelPropertyMap <T> elementMapping) : base(member)
{
ElementMap = elementMapping ?? throw new ArgumentNullException(nameof(elementMapping));
var columnReader = new ColumnNameValueReader(member.Name);
ColumnsReader = new SplitCellValueReader(columnReader);
}
public void InnerReader_SetValid_GetReturnsExpected()
{
var reader = new OptionalCellValueReader(new ColumnNameValueReader("ColumnName1"));
var innerReader = new ColumnNameValueReader("ColumnName2");
reader.InnerReader = innerReader;
Assert.Same(innerReader, reader.InnerReader);
}
public void WithMapper_ValidMapper_Success()
{
var reader = new ColumnNameValueReader("ColumnName");
SingleExcelPropertyMap <string> propertyMap = Map(t => t.Value);
Assert.Same(propertyMap, propertyMap.WithReader(reader));
Assert.Same(reader, propertyMap.CellReader);
}
public void Ctor_CellReader()
{
var innerReader = new ColumnNameValueReader("ColumnName");
var reader = new SubSplitCellValueReader(innerReader);
Assert.Same(innerReader, reader.CellReader);
Assert.Equal(StringSplitOptions.None, reader.Options);
}
public void WithReader_OptionalColumn_Success()
{
var innerReader = new ColumnNameValueReader("ColumnName");
OneToOneMap <string> propertyMap = Map(t => t.Value).MakeOptional();
Assert.True(propertyMap.Optional);
Assert.Same(propertyMap, propertyMap.WithReader(innerReader));
Assert.True(propertyMap.Optional);
Assert.Same(innerReader, propertyMap.CellReader);
}
public void Ctor_CellReader()
{
var innerReader = new ColumnNameValueReader("ColumnName");
var reader = new CharSplitCellValueReader(innerReader);
Assert.Same(innerReader, reader.CellReader);
Assert.Equal(StringSplitOptions.None, reader.Options);
Assert.Equal(new char[] { ',' }, reader.Separators);
}
public void WithColumnName_ValidColumnName_Success()
{
SingleExcelPropertyMap <string> propertyMap = Map(t => t.Value);
Assert.Same(propertyMap, propertyMap.WithColumnName("ColumnName"));
ColumnNameValueReader reader = Assert.IsType <ColumnNameValueReader>(propertyMap.CellReader);
Assert.Equal("ColumnName", reader.ColumnName);
}
public void RemoveCellValueMapper_Index_Success()
{
var reader = new ColumnNameValueReader("Column");
var map = new SubOneToOneMap <int>(reader);
map.AddCellValueMapper(new BoolMapper());
map.RemoveCellValueMapper(0);
Assert.Empty(map.CellValueMappers);
}
public void CellReader_SetValid_GetReturnsExpected()
{
var innerReader = new ColumnNameValueReader("ColumnName1");
var reader = new SplitCellValueReader(new ColumnNameValueReader("ColumnName2"))
{
CellReader = innerReader
};
Assert.Same(innerReader, reader.CellReader);
}
public void AddCellValueMapper_ValidItem_Success()
{
var reader = new ColumnNameValueReader("Column");
var map = new SubOneToOneMap <int>(reader);
var item1 = new BoolMapper();
var item2 = new BoolMapper();
map.AddCellValueMapper(item1);
map.AddCellValueMapper(item2);
Assert.Equal(new ICellValueMapper[] { item1, item2 }, map.CellValueMappers);
}
public void CellReader_SetValid_GetReturnsExpected()
{
var cellReader = new ColumnNameValueReader("ColumnName");
MemberInfo propertyInfo = typeof(TestClass).GetProperty(nameof(TestClass.Value));
var propertyMap = new SingleExcelPropertyMap(propertyInfo)
{
CellReader = cellReader
};
Assert.Same(cellReader, propertyMap.CellReader);
}
public void WithColumnName_OptionalColumn_Success()
{
SingleExcelPropertyMap <string> propertyMap = Map(t => t.Value).MakeOptional();
Assert.Same(propertyMap, propertyMap.WithColumnName("ColumnName"));
OptionalCellValueReader reader = Assert.IsType <OptionalCellValueReader>(propertyMap.CellReader);
ColumnNameValueReader innerReader = Assert.IsType <ColumnNameValueReader>(reader.InnerReader);
Assert.Equal("ColumnName", innerReader.ColumnName);
}
public void AddCellValueTransformer_ValidTransformer_Success()
{
var reader = new ColumnNameValueReader("Column");
var map = new SubOneToOneMap <int>(reader);
var transformer1 = new TrimCellValueTransformer();
var transformer2 = new TrimCellValueTransformer();
map.AddCellValueTransformer(transformer1);
map.AddCellValueTransformer(transformer2);
Assert.Equal(new ICellValueTransformer[] { transformer1, transformer2 }, map.CellValueTransformers);
}
public void WithColumnName_MultiValidColumnName_Success()
{
MemberInfo propertyInfo = typeof(TestClass).GetProperty(nameof(TestClass.Value));
var propertyMap = new SubPropertyMap(propertyInfo).WithColumnNames("ColumnName");
Assert.Same(propertyMap, propertyMap.WithColumnName("ColumnName"));
SplitCellValueReader valueReader = Assert.IsType <SplitCellValueReader>(propertyMap.ColumnsReader);
ColumnNameValueReader innerReader = Assert.IsType <ColumnNameValueReader>(valueReader.CellReader);
Assert.Equal("ColumnName", innerReader.ColumnName);
}
public void WithReader_OptionalColumn_Success()
{
var innerReader = new ColumnNameValueReader("ColumnName");
SingleExcelPropertyMap <string> propertyMap = Map(t => t.Value).MakeOptional();
Assert.Same(propertyMap, propertyMap.WithReader(innerReader));
OptionalCellValueReader reader = Assert.IsType <OptionalCellValueReader>(propertyMap.CellReader);
Assert.Same(innerReader, reader.InnerReader);
}
public void WithColumnName_OptionalColumn_Success()
{
OneToOneMap <string> propertyMap = Map(t => t.Value).MakeOptional();
Assert.True(propertyMap.Optional);
Assert.Same(propertyMap, propertyMap.WithColumnName("ColumnName"));
Assert.True(propertyMap.Optional);
ColumnNameValueReader innerReader = Assert.IsType <ColumnNameValueReader>(propertyMap.CellReader);
Assert.Equal("ColumnName", innerReader.ColumnName);
}
public void InvalidFallback_Set_GetReturnsExpected()
{
var reader = new ColumnNameValueReader("Column");
var map = new SubOneToOneMap <int>(reader);
var fallback = new FixedValueFallback(10);
map.InvalidFallback = fallback;
Assert.Same(fallback, map.InvalidFallback);
map.InvalidFallback = null;
Assert.Null(map.InvalidFallback);
}
public void Ctor_ISingleCellValueReader()
{
var reader = new ColumnNameValueReader("Column");
var map = new SubOneToOneMap <int>(reader);
Assert.Same(reader, map.CellReader);
Assert.Empty(map.CellValueMappers);
Assert.Same(map.CellValueMappers, map.CellValueMappers);
Assert.Same(map.CellValueMappers, map.Pipeline.CellValueMappers);
Assert.Empty(map.CellValueTransformers);
Assert.Same(map.CellValueTransformers, map.CellValueTransformers);
Assert.Same(map.CellValueTransformers, map.Pipeline.CellValueTransformers);
Assert.False(map.Optional);
}
public void CellReader_SetValid_GetReturnsExpected(ISingleCellValueReader value)
{
var reader = new ColumnNameValueReader("Column");
var map = new SubOneToOneMap <int>(reader)
{
CellReader = value
};
Assert.Same(value, map.CellReader);
// Set same.
map.CellReader = value;
Assert.Same(value, map.CellReader);
}
public void WithColumnName_MultiValidColumnName_Success()
{
var cellValuesReader = new MultipleColumnNamesValueReader("Column");
var elementPipeline = new ValuePipeline <string>();
CreateElementsFactory <string> createElementsFactory = elements => elements;
var propertyMap = new ManyToOneEnumerableMap <string>(cellValuesReader, elementPipeline, createElementsFactory).WithColumnNames("ColumnName");
Assert.Same(propertyMap, propertyMap.WithColumnName("ColumnName"));
CharSplitCellValueReader valueReader = Assert.IsType <CharSplitCellValueReader>(propertyMap.CellValuesReader);
ColumnNameValueReader innerReader = Assert.IsType <ColumnNameValueReader>(valueReader.CellReader);
Assert.Equal("ColumnName", innerReader.ColumnName);
}
/// <summary>
/// Sets the reader for multiple values to split the value of a single cell contained in the column
/// with a given name.
/// </summary>
/// <param name="columnName">The name of the column containing the cell to split.</param>
/// <returns>The property map that invoked this method.</returns>
public EnumerableExcelPropertyMap <T> WithColumnName(string columnName)
{
var columnReader = new ColumnNameValueReader(columnName);
if (ColumnsReader is SplitCellValueReader splitColumnReader)
{
splitColumnReader.CellReader = columnReader;
}
else
{
ColumnsReader = new SplitCellValueReader(columnReader);
}
return(this);
}
public void Optional_Set_GetReturnsExpected(bool value)
{
var reader = new ColumnNameValueReader("Column");
var map = new SubOneToOneMap <int>(reader)
{
Optional = value
};
Assert.Equal(value, map.Optional);
// Set same.
map.Optional = value;
Assert.Equal(value, map.Optional);
// Set different.
map.Optional = !value;
Assert.Equal(!value, map.Optional);
}
public void Ctor_ColumnName()
{
var reader = new ColumnNameValueReader("ColumnName");
Assert.Equal("ColumnName", reader.ColumnName);
}
