public void Metadata_methods_throw_if_reader_is_closed()
{
var reader = Common.Internal.Materialization.MockHelper.CreateDbDataReader(new[] { new[] { new object() } });
var bufferedDataReader = new BufferedDataReader(reader);
bufferedDataReader.Initialize("2008", FakeSqlProviderServices.Instance);
bufferedDataReader.Close();
Assert.Equal(
Strings.ADP_ClosedDataReaderError,
Assert.Throws <InvalidOperationException>(() => bufferedDataReader.FieldCount).Message);
Assert.Equal(
Strings.ADP_ClosedDataReaderError,
Assert.Throws <InvalidOperationException>(() => bufferedDataReader.GetOrdinal("columnName")).Message);
Assert.Equal(
Strings.ADP_ClosedDataReaderError,
Assert.Throws <InvalidOperationException>(() => bufferedDataReader.GetDataTypeName(0)).Message);
Assert.Equal(
Strings.ADP_ClosedDataReaderError,
Assert.Throws <InvalidOperationException>(() => bufferedDataReader.GetFieldType(0)).Message);
Assert.Equal(
Strings.ADP_ClosedDataReaderError,
Assert.Throws <InvalidOperationException>(() => bufferedDataReader.GetName(0)).Message);
}
private void Metadata_methods_return_expected_results(bool async)
{
var reader = Common.Internal.Materialization.MockHelper.CreateDbDataReader(new[] { new[] { new object() } });
var readerMock = Mock.Get(reader);
readerMock.Setup(m => m.RecordsAffected).Returns(2);
readerMock.Setup(m => m.GetOrdinal(It.IsAny <string>())).Returns(3);
readerMock.Setup(m => m.GetDataTypeName(It.IsAny <int>())).Returns("dataTypeName");
readerMock.Setup(m => m.GetFieldType(It.IsAny <int>())).Returns(typeof(DBNull));
readerMock.Setup(m => m.GetName(It.IsAny <int>())).Returns("columnName");
var bufferedDataReader = new BufferedDataReader(reader);
if (async)
{
#if !NET40
bufferedDataReader.InitializeAsync("2008", FakeSqlProviderServices.Instance, CancellationToken.None).Wait();
#endif
}
else
{
bufferedDataReader.Initialize("2008", FakeSqlProviderServices.Instance);
}
Assert.Equal(1, bufferedDataReader.FieldCount);
Assert.Equal(0, bufferedDataReader.GetOrdinal("columnName"));
Assert.Equal("dataTypeName", bufferedDataReader.GetDataTypeName(0));
Assert.Equal(typeof(DBNull), bufferedDataReader.GetFieldType(0));
Assert.Equal("columnName", bufferedDataReader.GetName(0));
Assert.Throws <NotSupportedException>(() => bufferedDataReader.Depth);
Assert.Throws <NotSupportedException>(() => bufferedDataReader.GetSchemaTable());
bufferedDataReader.Close();
Assert.Equal(2, bufferedDataReader.RecordsAffected);
}
public void Close_disposes_underlying_reader()
{
var reader = Common.Internal.Materialization.MockHelper.CreateDbDataReader(new[] { new[] { new object() } });
var bufferedReader = new BufferedDataReader(reader);
Assert.False(reader.IsClosed);
bufferedReader.Close();
Assert.True(reader.IsClosed);
}
public void InitializeAsync_does_not_throw_OperationCanceledException_if_reader_is_null_even_if_task_is_cancelled()
{
var reader = new BufferedDataReader(new Mock <DbDataReader>().Object);
reader.Close();
Assert.False(reader.InitializeAsync("manifestToken", new Mock <DbProviderServices>().Object,
new Type[0], new bool[0], new CancellationToken(canceled: true)).IsCanceled);
}
private void Manipulation_methods_perform_expected_actions(bool spatial, bool async)
{
var reader = Common.Internal.Materialization.MockHelper.CreateDbDataReader(
new[] { new object[] { 1, "a" } }, new object[0][]);
var bufferedDataReader = new BufferedDataReader(reader);
var spatialDataReaderMock = new Mock <DbSpatialDataReader>();
var providerServicesMock = new Mock <DbProviderServices>();
if (spatial)
{
spatialDataReaderMock.Setup(m => m.IsGeographyColumn(0)).Returns(true);
spatialDataReaderMock.Setup(m => m.IsGeometryColumn(1)).Returns(true);
#if !NET40
if (async)
{
spatialDataReaderMock.Setup(m => m.GetGeographyAsync(It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Returns(() => Task.FromResult((DbGeography)null));
spatialDataReaderMock.Setup(m => m.GetGeometryAsync(It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Returns(() => Task.FromResult((DbGeometry)null));
}
#endif
providerServicesMock.Protected()
.Setup <DbSpatialDataReader>("GetDbSpatialDataReader", reader, "2008")
.Returns(spatialDataReaderMock.Object);
}
try
{
Assert.False(bufferedDataReader.IsClosed);
if (async)
{
#if !NET40
bufferedDataReader.InitializeAsync("2008", providerServicesMock.Object, CancellationToken.None).Wait();
#endif
}
else
{
bufferedDataReader.Initialize("2008", providerServicesMock.Object);
}
Assert.False(bufferedDataReader.IsClosed);
}
finally
{
MutableResolver.ClearResolvers();
}
if (spatial)
{
if (async)
{
#if !NET40
spatialDataReaderMock.Verify(m => m.GetGeographyAsync(It.IsAny <int>(), It.IsAny <CancellationToken>()), Times.Once());
spatialDataReaderMock.Verify(m => m.GetGeometryAsync(It.IsAny <int>(), It.IsAny <CancellationToken>()), Times.Once());
#endif
}
else
{
spatialDataReaderMock.Verify(m => m.GetGeography(It.IsAny <int>()), Times.Once());
spatialDataReaderMock.Verify(m => m.GetGeometry(It.IsAny <int>()), Times.Once());
}
}
Assert.True(bufferedDataReader.HasRows);
if (async)
{
#if !NET40
Assert.True(bufferedDataReader.ReadAsync().Result);
Assert.False(bufferedDataReader.ReadAsync().Result);
#endif
}
else
{
Assert.True(bufferedDataReader.Read());
Assert.False(bufferedDataReader.Read());
}
Assert.True(bufferedDataReader.HasRows);
if (async)
{
#if !NET40
Assert.True(bufferedDataReader.NextResultAsync().Result);
#endif
}
else
{
Assert.True(bufferedDataReader.NextResult());
}
Assert.False(bufferedDataReader.HasRows);
if (async)
{
#if !NET40
Assert.False(bufferedDataReader.ReadAsync().Result);
Assert.False(bufferedDataReader.NextResultAsync().Result);
#endif
}
else
{
Assert.False(bufferedDataReader.Read());
Assert.False(bufferedDataReader.NextResult());
}
Assert.False(bufferedDataReader.IsClosed);
bufferedDataReader.Close();
Assert.True(bufferedDataReader.IsClosed);
}