public async Task ParsesThroughGlobalDataTransformer()
{
var rdr = new Mock <DbDataReader>();
rdr.Setup(r => r.GetFieldType(0)).Returns(typeof(int));
rdr.Setup(r => r.GetValue(0)).Returns(99);
rdr.SetupSequence(r => r.ReadAsync(It.IsAny <CancellationToken>()))
.ReturnsAsync(true)
.ReturnsAsync(false);
var xformer = new Mock <IDataTransformer>();
xformer.Setup(x => x.CanTransform(99, typeof(int), false, It.Is <IEnumerable <Attribute> >(attrs => attrs != null)))
.Returns(true);
xformer.Setup(x => x.Transform(99, typeof(int), false, It.Is <IEnumerable <Attribute> >(attrs => attrs != null)))
.Returns(42);
using (GlobalSettings.UseTestInstance())
{
StoredProcedure.AddGlobalTransformer(xformer.Object);
var toTest = new SimpleTypeRowFactory <int>();
var res = await toTest.ParseRowsAsync(rdr.Object, new IDataTransformer[0], CancellationToken.None);
res.Single().Should().Be(42);
}
}
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 GlobalIDataTransformer_TransformsData()
{
var rdr = new Mock <IDataReader>();
rdr.Setup(r => r.FieldCount).Returns(1);
rdr.Setup(r => r.GetFieldType(0)).Returns(typeof(string));
rdr.Setup(r => r.GetName(0)).Returns("Name");
rdr.Setup(r => r.GetValues(It.IsAny <object[]>()))
.Callback <object[]>(os => os[0] = "Blah");
rdr.SetupSequence(r => r.Read())
.Returns(true)
.Returns(false);
var xf = new Mock <IDataTransformer>();
xf.Setup(x => x.CanTransform("Blah", typeof(string), true, It.IsAny <IEnumerable <Attribute> >()))
.Returns(true);
xf.Setup(x => x.Transform("Blah", typeof(string), true, It.IsAny <IEnumerable <Attribute> >()))
.Returns("foobar");
using (GlobalSettings.UseTestInstance())
{
StoredProcedure.AddGlobalTransformer(xf.Object);
var toTest = new ExpandoObjectRowFactory <dynamic>();
var res = toTest.ParseRows(rdr.Object, new IDataTransformer[0], CancellationToken.None);
var item = res.Should().ContainSingle("because only 1 row should have been returned").Which;
((string)item.Name).Should().Be("foobar", "because it should have been transformed");
}
}
public void ReturnsEnumViaNameTransformsStringBeforeParsing_WithGlobalTransformer()
{
using (GlobalSettings.UseTestInstance())
{
var rdr = new Mock <IDataReader>();
rdr.Setup(r => r.GetFieldType(0)).Returns(typeof(string));
rdr.Setup(r => r.GetString(0)).Returns("One");
rdr.SetupSequence(r => r.Read())
.Returns(true)
.Returns(false);
var toTest = new EnumRowFactory <IntEnum>();
var xf = new Mock <IDataTransformer>();
xf.Setup(x => x.CanTransform("One", typeof(IntEnum), false, It.Is <IEnumerable <Attribute> >(attrs => attrs != null)))
.Returns(true);
xf.Setup(x => x.Transform("One", typeof(IntEnum), false, It.Is <IEnumerable <Attribute> >(attrs => attrs != null)))
.Returns("Two");
StoredProcedure.AddGlobalTransformer(xf.Object);
toTest.ParseRows(rdr.Object, new IDataTransformer[0], CancellationToken.None)
.Single().Should().Be(IntEnum.Two);
}
}
