public void InitializeAsync_is_idempotent() { var reader = Common.Internal.Materialization.MockHelper.CreateDbDataReader(new[] { new[] { new object() } }); var bufferedReader = new BufferedDataReader(reader); Assert.False(reader.IsClosed); bufferedReader.InitializeAsync("2008", FakeSqlProviderServices.Instance, CancellationToken.None).Wait(); Assert.True(reader.IsClosed); bufferedReader.InitializeAsync("2008", FakeSqlProviderServices.Instance, CancellationToken.None).Wait(); }
private void Metadata_methods_return_expected_results(bool async, bool shaped) { 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 columnTypes = new[] { typeof(object) }; var nullableColumns = new[] { true }; var bufferedDataReader = new BufferedDataReader(reader); if (async) { #if !NET40 if (shaped) { bufferedDataReader.InitializeAsync( "2008", FakeSqlProviderServices.Instance, columnTypes, nullableColumns, CancellationToken.None).Wait(); } else { bufferedDataReader.InitializeAsync("2008", FakeSqlProviderServices.Instance, null, null, CancellationToken.None).Wait(); } #endif } else { if (shaped) { bufferedDataReader.Initialize("2008", FakeSqlProviderServices.Instance, columnTypes, nullableColumns); } else { bufferedDataReader.Initialize("2008", FakeSqlProviderServices.Instance, null, null); } } 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 InitializeAsync_throws_OperationCanceledException_if_task_is_cancelled() { var reader = new BufferedDataReader(new Mock <DbDataReader>().Object); Assert.Throws <OperationCanceledException>( () => reader.InitializeAsync("manifestToken", new Mock <DbProviderServices>().Object, new Type[0], new bool[0], new CancellationToken(canceled: true)) .GetAwaiter().GetResult()); }
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 Verify_method_result <T>( Func <BufferedDataReader, T> method, bool async, bool shaped, T expectedResult, params IEnumerable <object[]>[] dataReaderContents) { var reader = Common.Internal.Materialization.MockHelper.CreateDbDataReader(dataReaderContents); var columnTypes = new[] { typeof(T) }; var nullableColumns = new[] { true }; var bufferedReader = new BufferedDataReader(reader); if (async) { #if !NET40 if (shaped) { bufferedReader.InitializeAsync( "2008", FakeSqlProviderServices.Instance, columnTypes, nullableColumns, CancellationToken.None).Wait(); } else { bufferedReader.InitializeAsync("2008", FakeSqlProviderServices.Instance, null, null, CancellationToken.None).Wait(); } Assert.True(bufferedReader.ReadAsync().Result); #endif } else { if (shaped) { bufferedReader.Initialize("2008", FakeSqlProviderServices.Instance, columnTypes, nullableColumns); } else { bufferedReader.Initialize("2008", FakeSqlProviderServices.Instance, null, null); } Assert.True(bufferedReader.Read()); } Assert.Equal(expectedResult, method(bufferedReader)); }
internal virtual async Task <ObjectResult <TResultType> > ExecuteAsync <TResultType>( ObjectContext context, ObjectParameterCollection parameterValues, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); DbDataReader storeReader = (DbDataReader)null; BufferedDataReader bufferedReader = (BufferedDataReader)null; ObjectResult <TResultType> objectResult; try { using (EntityCommand entityCommand = this.PrepareEntityCommand(context, parameterValues)) storeReader = await entityCommand.GetCommandDefinition().ExecuteStoreCommandsAsync(entityCommand, this.Streaming ? CommandBehavior.Default : CommandBehavior.SequentialAccess, cancellationToken).WithCurrentCulture <DbDataReader>(); ShaperFactory <TResultType> shaperFactory = (ShaperFactory <TResultType>) this.ResultShaperFactory; Shaper <TResultType> shaper; if (this.Streaming) { shaper = shaperFactory.Create(storeReader, context, context.MetadataWorkspace, this.MergeOption, true, this.Streaming); } else { StoreItemCollection storeItemCollection = (StoreItemCollection)context.MetadataWorkspace.GetItemCollection(DataSpace.SSpace); DbProviderServices providerServices = DbConfiguration.DependencyResolver.GetService <DbProviderServices>((object)storeItemCollection.ProviderInvariantName); bufferedReader = new BufferedDataReader(storeReader); await bufferedReader.InitializeAsync(storeItemCollection.ProviderManifestToken, providerServices, shaperFactory.ColumnTypes, shaperFactory.NullableColumns, cancellationToken).WithCurrentCulture(); shaper = shaperFactory.Create((DbDataReader)bufferedReader, context, context.MetadataWorkspace, this.MergeOption, true, this.Streaming); } TypeUsage resultItemEdmType = this.ResultType.EdmType.BuiltInTypeKind != BuiltInTypeKind.CollectionType ? this.ResultType : ((CollectionType)this.ResultType.EdmType).TypeUsage; objectResult = new ObjectResult <TResultType>(shaper, this._singleEntitySet, resultItemEdmType); } catch (Exception ex) { if (this.Streaming && storeReader != null) { storeReader.Dispose(); } if (!this.Streaming && bufferedReader != null) { bufferedReader.Dispose(); } throw; } return(objectResult); }
internal virtual async Task <ObjectResult <TResultType> > ExecuteAsync <TResultType>( ObjectContext context, ObjectParameterCollection parameterValues, CancellationToken cancellationToken) { DbDataReader storeReader = null; BufferedDataReader bufferedReader = null; try { using (var entityCommand = PrepareEntityCommand(context, parameterValues)) { // acquire store reader storeReader = await entityCommand.GetCommandDefinition() .ExecuteStoreCommandsAsync( entityCommand, Streaming ? CommandBehavior.Default : CommandBehavior.SequentialAccess , cancellationToken) .ConfigureAwait(continueOnCapturedContext: false); } var shaperFactory = (ShaperFactory <TResultType>)ResultShaperFactory; Shaper <TResultType> shaper; if (Streaming) { shaper = shaperFactory.Create( storeReader, context, context.MetadataWorkspace, MergeOption, true, useSpatialReader: true, shouldReleaseConnection: Streaming); } else { var storeItemCollection = (StoreItemCollection)context.MetadataWorkspace.GetItemCollection(DataSpace.SSpace); var providerServices = DbConfiguration.DependencyResolver.GetService <DbProviderServices>(storeItemCollection.StoreProviderInvariantName); bufferedReader = new BufferedDataReader(storeReader); await bufferedReader.InitializeAsync(storeItemCollection.StoreProviderManifestToken, providerServices, cancellationToken) .ConfigureAwait(continueOnCapturedContext: false); shaper = shaperFactory.Create( bufferedReader, context, context.MetadataWorkspace, MergeOption, true, useSpatialReader: false, shouldReleaseConnection: Streaming); } // create materializer delegate TypeUsage resultItemEdmType; if (ResultType.EdmType.BuiltInTypeKind == BuiltInTypeKind.CollectionType) { resultItemEdmType = ((CollectionType)ResultType.EdmType).TypeUsage; } else { resultItemEdmType = ResultType; } return(new ObjectResult <TResultType>(shaper, _singleEntitySet, resultItemEdmType)); } catch (Exception) { // Note: The ObjectResult is responsible for disposing the reader if creating // the enumerator fails. if (Streaming && storeReader != null) { storeReader.Dispose(); } if (!Streaming && bufferedReader != null) { bufferedReader.Dispose(); } throw; } }
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); }