public async Task ReturnsNullableEnumValuesViaName()
{
var rdr = new Mock <DbDataReader>();
rdr.Setup(r => r.GetFieldType(0)).Returns(typeof(string));
rdr.SetupSequence(r => r.IsDBNull(0))
.Returns(false)
.Returns(true)
.Returns(false)
.Returns(false);
rdr.SetupSequence(r => r.GetString(0))
.Returns("One")
.Returns("Two")
.Returns("Zero");
rdr.SetupSequence(r => r.ReadAsync(It.IsAny <CancellationToken>()))
.ReturnsAsync(true)
.ReturnsAsync(true)
.ReturnsAsync(true)
.ReturnsAsync(true)
.ReturnsAsync(false);
var toTest = RowFactory <IntEnum?> .Create();
var res = await toTest.ParseRowsAsync(rdr.Object, Enumerable.Empty <IDataTransformer>(), CancellationToken.None);
res.Should().ContainInOrder(IntEnum.One, null, IntEnum.Two, IntEnum.Zero);
}
public void ReturnsNullableEnumValuesViaNameTransformsBeforeParsing_WithGlobalTransformer()
{
using (GlobalSettings.UseTestInstance())
{
var rdr = new Mock <IDataReader>();
rdr.Setup(r => r.GetFieldType(0)).Returns(typeof(string));
rdr.SetupSequence(r => r.IsDBNull(0))
.Returns(false)
.Returns(true)
.Returns(false)
.Returns(false);
rdr.SetupSequence(r => r.GetString(0))
.Returns("Blah")
.Returns("Two")
.Returns("Zero");
rdr.SetupSequence(r => r.Read())
.Returns(true)
.Returns(true)
.Returns(true)
.Returns(true)
.Returns(false);
var toTest = RowFactory <IntEnum?> .Create();
var xf = new Mock <IDataTransformer>();
xf.Setup(x => x.CanTransform("Blah", typeof(IntEnum), true, It.Is <IEnumerable <Attribute> >(attrs => attrs != null)))
.Returns(true);
xf.Setup(x => x.Transform("Blah", typeof(IntEnum), true, It.Is <IEnumerable <Attribute> >(attrs => attrs != null)))
.Returns("One");
StoredProcedure.AddGlobalTransformer(xf.Object);
toTest.ParseRows(rdr.Object, new IDataTransformer[0], CancellationToken.None)
.Should().ContainInOrder(IntEnum.One, null, IntEnum.Two, IntEnum.Zero);
}
}
public void ReturnsNullableEnumValuesViaBoxedValue()
{
var rdr = new Mock <IDataReader>();
rdr.Setup(r => r.GetFieldType(0)).Returns(typeof(int));
rdr.SetupSequence(r => r.IsDBNull(0))
.Returns(false)
.Returns(true)
.Returns(false)
.Returns(false);
rdr.SetupSequence(r => r.GetValue(0))
.Returns(-1)
.Returns(2)
.Returns(0);
rdr.SetupSequence(r => r.Read())
.Returns(true)
.Returns(true)
.Returns(true)
.Returns(true)
.Returns(false);
var toTest = RowFactory <IntEnum?> .Create();
var xf = new Mock <IDataTransformer>();
xf.Setup(x => x.CanTransform(-1, typeof(IntEnum), true, It.Is <IEnumerable <Attribute> >(attrs => attrs != null)))
.Returns(true);
xf.Setup(x => x.Transform(-1, typeof(IntEnum), true, It.Is <IEnumerable <Attribute> >(attrs => attrs != null)))
.Returns(1);
toTest.ParseRows(rdr.Object, new[] { xf.Object }, CancellationToken.None)
.Should().ContainInOrder(IntEnum.One, null, IntEnum.Two, IntEnum.Zero);
}
public void ReturnsNullableEnumValuesViaValue()
{
var rdr = new Mock <IDataReader>();
rdr.Setup(r => r.GetFieldType(0)).Returns(typeof(int));
rdr.SetupSequence(r => r.IsDBNull(0))
.Returns(false)
.Returns(true)
.Returns(false)
.Returns(false);
rdr.SetupSequence(r => r.GetInt32(0))
.Returns(1)
.Returns(2)
.Returns(0);
rdr.SetupSequence(r => r.Read())
.Returns(true)
.Returns(true)
.Returns(true)
.Returns(true)
.Returns(false);
var toTest = RowFactory <IntEnum?> .Create();
toTest.ParseRows(rdr.Object, Enumerable.Empty <IDataTransformer>(), CancellationToken.None)
.Should().ContainInOrder(IntEnum.One, null, IntEnum.Two, IntEnum.Zero);
}
/// <summary>
/// TestReader has to account for 4 system fields that are present
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
private static TestReader GetTestReader(Entity entity)
{
var capacity = entity.GetAllFields().Count();
var rowFactory = new RowFactory(capacity, false, false);
var row1 = rowFactory.Create();
row1[entity.Fields[0]] = 1;
row1[entity.Fields[1]] = "One";
var row2 = rowFactory.Create();
row2[entity.Fields[0]] = 2;
row2[entity.Fields[1]] = "Two";
var data = new List <IRow> {
row1, row2
};
return(new TestReader(data));
}
public void ParsesNullableDoubleAsNull()
{
var rdr = new Mock <IDataReader>();
rdr.Setup(r => r.GetFieldType(0)).Returns(typeof(double));
rdr.Setup(r => r.IsDBNull(0)).Returns(true);
rdr.SetupSequence(r => r.Read())
.Returns(true)
.Returns(false);
var toTest = RowFactory <double?> .Create();
toTest.ParseRows(rdr.Object, Enumerable.Empty <IDataTransformer>(), CancellationToken.None)
.Single().Should().Be(default(Nullable <double>));
}
private static void Assert <T, TFactory>(string typeName = null)
where TFactory : IRowFactory <T>
{
if (typeName == null)
{
typeName = typeof(T).Name;
}
var result = RowFactory <T> .Create();
var typeF = typeof(TFactory);
var factoryName = typeF.Name.Substring(0, typeF.Name.Length - 2); // get rid of the `1
result.Should().NotBeNull("result should not be null");
result.RowType.Should().BeSameAs(typeof(T), "result should have RowType set to {0}", typeName);
result.Should().BeOfType <TFactory>("result should be of type {0}<{1}>", factoryName, typeName);
}
private IEnumerable <T> GetResults <T>(bool isSingle)
{
if (resultTask == null)
{
throw new NotSupportedException("When calling the dynamic syntax with a NonQuery variant, no results are returned, so the value can not be cast to a result set.");
}
try
{
return(RowFactory <T> .Create(isSingle).ParseRows(resultTask.Result, transformers, token));
}
finally
{
if (isSingle)
{
ReadToEnd();
resultTask.Result.Dispose();
}
}
}
public RootHierarchicalRowInfo() : base(itemType: typeof(TItem), rowFactory: RowFactory <TItem> .Create(false))
{
}