public void StoreConnection_state_mimics_EntityConnection_state_if_only_EntityConnection_is_used_without_txn() { var storeConnectionState = ConnectionState.Closed; var storeConnectionMock = new Mock <DbConnection>(MockBehavior.Strict); storeConnectionMock.Setup(m => m.OpenAsync(It.IsAny <CancellationToken>())).Callback( () => storeConnectionState = ConnectionState.Open).Returns(Task.FromResult(1)); storeConnectionMock.Setup(m => m.Close()).Callback(() => storeConnectionState = ConnectionState.Closed); storeConnectionMock.SetupGet(m => m.State).Returns(() => storeConnectionState); var metadataWorkspaceMock = new Mock <MetadataWorkspace>(MockBehavior.Strict); metadataWorkspaceMock.Setup(m => m.IsItemCollectionAlreadyRegistered(DataSpace.SSpace)).Returns(true); var entityConnection = new EntityConnection(metadataWorkspaceMock.Object, storeConnectionMock.Object, true); Assert.Equal(ConnectionState.Closed, entityConnection.State); // entityConnection state Assert.Equal(ConnectionState.Closed, entityConnection.StoreConnection.State); // underlying storeConnection state // open entityConnection (automatically opens store connection) entityConnection.OpenAsync().Wait(); Assert.Equal(ConnectionState.Open, entityConnection.State); // entityConnection state Assert.Equal(ConnectionState.Open, entityConnection.StoreConnection.State); // underlying storeConnection state // close entityConnection without explicitly closing underlying store connection entityConnection.Close(); Assert.Equal(ConnectionState.Closed, entityConnection.State); // entityConnection state Assert.Equal(ConnectionState.Closed, entityConnection.StoreConnection.State); // underlying storeConnection state }
public void EntityConnection_automatically_closed_if_underlying_StoreConnection_is_closed_without_txn() { var storeConnectionState = ConnectionState.Closed; var storeConnectionMock = new Mock <DbConnection>(MockBehavior.Strict); storeConnectionMock.Setup(m => m.OpenAsync(It.IsAny <CancellationToken>())).Callback( () => storeConnectionState = ConnectionState.Open).Returns(Task.FromResult(1)); storeConnectionMock.Setup(m => m.Close()).Callback(() => storeConnectionState = ConnectionState.Closed); storeConnectionMock.SetupGet(m => m.State).Returns(() => storeConnectionState); var metadataWorkspaceMock = new Mock <MetadataWorkspace>(MockBehavior.Strict); metadataWorkspaceMock.Setup(m => m.IsItemCollectionAlreadyRegistered(DataSpace.SSpace)).Returns(true); // open entityConnection - both entityConnection and store connection should now be open var entityConnection = new EntityConnection(metadataWorkspaceMock.Object, storeConnectionMock.Object, true); entityConnection.OpenAsync().Wait(); Assert.Equal(ConnectionState.Open, entityConnection.State); // entityConnection state Assert.Equal(ConnectionState.Open, entityConnection.StoreConnection.State); // underlying storeConnection state // now close the underlying store connection without explicitly closing entityConnection entityConnection.StoreConnection.Close(); Assert.Equal(ConnectionState.Closed, entityConnection.State); // entityConnection state automatically updated Assert.Equal(ConnectionState.Closed, entityConnection.StoreConnection.State); // now re-open the store connection and EntityConnection is "resurrected" to an Open state entityConnection.StoreConnection.OpenAsync().Wait(); Assert.Equal(ConnectionState.Open, entityConnection.State); Assert.Equal(ConnectionState.Open, entityConnection.StoreConnection.State); }
public void Exception_is_thrown_if_dbConnection_is_null() { var metadataWorkspaceMock = new Mock <MetadataWorkspace>(MockBehavior.Strict); var entityConnection = new EntityConnection(metadataWorkspaceMock.Object, null, true); AssertThrowsInAsyncMethod <InvalidOperationException>( Strings.EntityClient_ConnectionStringNeededBeforeOperation, () => entityConnection.OpenAsync().Wait()); }
public void Underlying_dbConnection_is_not_being_reopened_if_it_was_initally_open() { var dbConnectionMock = new Mock <DbConnection>(MockBehavior.Strict); dbConnectionMock.SetupGet(m => m.State).Returns(ConnectionState.Open); var metadataWorkspaceMock = new Mock <MetadataWorkspace>(MockBehavior.Strict); metadataWorkspaceMock.Setup(m => m.IsItemCollectionAlreadyRegistered(DataSpace.SSpace)).Returns(true); var entityConnection = new EntityConnection(metadataWorkspaceMock.Object, dbConnectionMock.Object, true); entityConnection.OpenAsync().Wait(); dbConnectionMock.Verify(m => m.OpenAsync(It.IsAny <CancellationToken>()), Times.Never()); Assert.Equal(ConnectionState.Open, dbConnectionMock.Object.State); }
public void EntityConnection_with_closed_underlying_connection_maintains_closed_if_metadata_initialization_fails() { var dbConnectionMock = new Mock <DbConnection>(MockBehavior.Strict); dbConnectionMock.Setup(m => m.OpenAsync(It.IsAny <CancellationToken>())).Returns( Task.FromResult(1)); dbConnectionMock.Setup(m => m.Close()).Verifiable(); dbConnectionMock.SetupGet(m => m.State).Returns(ConnectionState.Closed); var metadataWorkspaceMock = new Mock <MetadataWorkspace>(MockBehavior.Strict); metadataWorkspaceMock.Setup(m => m.IsItemCollectionAlreadyRegistered(DataSpace.SSpace)).Throws <InvalidOperationException>(); var entityConnection = new EntityConnection(metadataWorkspaceMock.Object, dbConnectionMock.Object, true); AssertThrowsInAsyncMethod <InvalidOperationException>(null, () => entityConnection.OpenAsync().Wait()); Assert.Equal(ConnectionState.Closed, entityConnection.State); }
public void Underlying_dbConnection_is_opened_if_it_was_initially_closed() { var dbConnectionState = ConnectionState.Closed; var dbConnectionMock = new Mock <DbConnection>(MockBehavior.Strict); dbConnectionMock.Setup(m => m.OpenAsync(It.IsAny <CancellationToken>())).Callback( () => dbConnectionState = ConnectionState.Open).Returns(Task.FromResult(1)); dbConnectionMock.SetupGet(m => m.State).Returns(() => dbConnectionState); var metadataWorkspaceMock = new Mock <MetadataWorkspace>(MockBehavior.Strict); metadataWorkspaceMock.Setup(m => m.IsItemCollectionAlreadyRegistered(DataSpace.SSpace)).Returns(true); var entityConnection = new EntityConnection(metadataWorkspaceMock.Object, dbConnectionMock.Object, true); entityConnection.OpenAsync().Wait(); dbConnectionMock.Verify(m => m.OpenAsync(It.IsAny <CancellationToken>()), Times.Once()); }
public void Opening_EntityConnection_asynchronously_sets_its_State_to_Opened() { var dbConnectionState = ConnectionState.Closed; var dbConnectionMock = new Mock <DbConnection>(MockBehavior.Strict); dbConnectionMock.Setup(m => m.OpenAsync(It.IsAny <CancellationToken>())).Callback( () => dbConnectionState = ConnectionState.Open).Returns(Task.FromResult(1)); dbConnectionMock.SetupGet(m => m.State).Returns(() => dbConnectionState); var metadataWorkspaceMock = new Mock <MetadataWorkspace>(MockBehavior.Strict); metadataWorkspaceMock.Setup(m => m.IsItemCollectionAlreadyRegistered(DataSpace.SSpace)).Returns(true); var entityConnection = new EntityConnection(metadataWorkspaceMock.Object, dbConnectionMock.Object, true); entityConnection.OpenAsync().Wait(); Assert.Equal(ConnectionState.Open, entityConnection.State); }
public void Underlying_dbConnection_is_being_closed_if_it_was_initially_closed_and_metadata_initialization_fails() { var dbConnectionState = ConnectionState.Closed; var dbConnectionMock = new Mock <DbConnection>(); dbConnectionMock.Setup(m => m.OpenAsync(It.IsAny <CancellationToken>())).Callback( () => dbConnectionState = ConnectionState.Open).Returns(Task.FromResult(1)); dbConnectionMock.Setup(m => m.Close()).Verifiable(); dbConnectionMock.SetupGet(m => m.State).Returns(() => dbConnectionState); var metadataWorkspaceMock = new Mock <MetadataWorkspace>(MockBehavior.Strict); metadataWorkspaceMock.Setup(m => m.IsItemCollectionAlreadyRegistered(DataSpace.SSpace)).Throws <InvalidOperationException>(); var entityConnection = new EntityConnection(metadataWorkspaceMock.Object, dbConnectionMock.Object, true); AssertThrowsInAsyncMethod <InvalidOperationException>(null, () => entityConnection.OpenAsync().Wait()); dbConnectionMock.Verify(m => m.Close(), Times.Once()); }
public void Exceptions_from_Underlying_dbConnection_are_wrapped() { var dbConnectionState = ConnectionState.Closed; var dbConnectionMock = new Mock <DbConnection>(MockBehavior.Strict); dbConnectionMock.Setup(m => m.OpenAsync(It.IsAny <CancellationToken>())).Throws( new AggregateException(new InvalidOperationException())); dbConnectionMock.SetupGet(m => m.State).Returns(() => dbConnectionState); var metadataWorkspaceMock = new Mock <MetadataWorkspace>(MockBehavior.Strict); metadataWorkspaceMock.Setup(m => m.IsItemCollectionAlreadyRegistered(DataSpace.SSpace)).Returns(true); var entityConnection = new EntityConnection(metadataWorkspaceMock.Object, dbConnectionMock.Object, true); AssertThrowsInAsyncMethod <EntityException>( Strings.EntityClient_ProviderSpecificError("Open"), () => entityConnection.OpenAsync().Wait()); dbConnectionMock.Verify(m => m.OpenAsync(It.IsAny <CancellationToken>()), Times.Once()); }
public void Exception_is_not_thrown_when_trying_to_open_already_opened_connection() { var dbConnectionMock = new Mock<DbConnection>(MockBehavior.Strict); dbConnectionMock.SetupGet(m => m.State).Returns(ConnectionState.Open); dbConnectionMock.SetupGet(m => m.DataSource).Returns(() => "fake"); var metadataWorkspace = CreateMetadataWorkspaceMock().Object; var entityConnection = new EntityConnection(metadataWorkspace, dbConnectionMock.Object, true, true); Assert.DoesNotThrow(() => entityConnection.OpenAsync().Wait()); }
public void Underlying_dbConnection_is_opened_if_it_was_initially_closed() { var dbConnectionState = ConnectionState.Closed; var dbConnectionMock = new Mock<DbConnection>(MockBehavior.Strict); dbConnectionMock.Setup(m => m.OpenAsync(It.IsAny<CancellationToken>())).Callback( () => dbConnectionState = ConnectionState.Open).Returns(Task.FromResult(1)); dbConnectionMock.SetupGet(m => m.State).Returns(() => dbConnectionState); dbConnectionMock.SetupGet(m => m.DataSource).Returns("fake"); var entityConnection = new EntityConnection(CreateMetadataWorkspaceMock().Object, dbConnectionMock.Object, true, true); entityConnection.OpenAsync().Wait(); dbConnectionMock.Raise( conn => conn.StateChange += null, new StateChangeEventArgs(ConnectionState.Closed, ConnectionState.Open)); dbConnectionMock.Verify(m => m.OpenAsync(It.IsAny<CancellationToken>()), Times.Once()); }
public void Opening_EntityConnection_asynchronously_sets_its_State_to_Opened() { var dbConnectionState = ConnectionState.Closed; var dbConnectionMock = new Mock<DbConnection>(MockBehavior.Strict); dbConnectionMock.Setup(m => m.OpenAsync(It.IsAny<CancellationToken>())).Callback( () => dbConnectionState = ConnectionState.Open).Returns(Task.FromResult(1)); dbConnectionMock.SetupGet(m => m.State).Returns(() => dbConnectionState); dbConnectionMock.SetupGet(m => m.DataSource).Returns("fake"); var entityConnection = new EntityConnection(CreateMetadataWorkspaceMock().Object, dbConnectionMock.Object, true, true); entityConnection.OpenAsync().Wait(); dbConnectionMock.Raise( conn => conn.StateChange += null, new StateChangeEventArgs(ConnectionState.Closed, ConnectionState.Open)); Assert.Equal(ConnectionState.Open, entityConnection.State); }
public void Exception_is_thrown_if_dbConnection_is_null() { var metadataWorkspaceMock = new Mock<MetadataWorkspace>(MockBehavior.Strict); var entityConnection = new EntityConnection(metadataWorkspaceMock.Object, null, true, true); Assert.Equal( Strings.EntityClient_ConnectionStringNeededBeforeOperation, Assert.Throws<InvalidOperationException>( () => ExceptionHelpers.UnwrapAggregateExceptions( () => entityConnection.OpenAsync().Wait())).Message); }
public void OperationCanceledException_thrown_before_opening_connection_if_task_is_cancelled() { var entityConnection = new EntityConnection( /* metadataWorkspace */ null, new Mock<DbConnection>().Object, /* skipInitialization */ true, false); Assert.Throws<OperationCanceledException>( () => entityConnection.OpenAsync(new CancellationToken(canceled: true)) .GetAwaiter().GetResult()); }
public void Exceptions_from_Underlying_dbConnection_are_wrapped() { var dbConnectionState = ConnectionState.Closed; var dbConnectionMock = new Mock<DbConnection>(MockBehavior.Strict); dbConnectionMock.Setup(m => m.OpenAsync(It.IsAny<CancellationToken>())).Throws( new AggregateException(new InvalidOperationException())); dbConnectionMock.SetupGet(m => m.State).Returns(() => dbConnectionState); dbConnectionMock.SetupGet(m => m.DataSource).Returns("fake"); var entityConnection = new EntityConnection(CreateMetadataWorkspaceMock().Object, dbConnectionMock.Object, true, true); Assert.Equal( Strings.EntityClient_ProviderSpecificError("Open"), Assert.Throws<EntityException>( () => ExceptionHelpers.UnwrapAggregateExceptions( () => entityConnection.OpenAsync().Wait())).Message); dbConnectionMock.Verify(m => m.OpenAsync(It.IsAny<CancellationToken>()), Times.Once()); }
public void Underlying_dbConnection_is_not_being_closed_if_it_was_initially_open_and_attempt_is_made_to_reopen_it() { var dbConnectionMock = new Mock<DbConnection>(MockBehavior.Strict); dbConnectionMock.Setup(m => m.OpenAsync(It.IsAny<CancellationToken>())).Returns(Task.FromResult(1)); dbConnectionMock.Setup(m => m.Close()).Verifiable(); dbConnectionMock.SetupGet(m => m.State).Returns(ConnectionState.Open); dbConnectionMock.SetupGet(m => m.DataSource).Returns("fake"); var entityConnection = new EntityConnection( new Mock<MetadataWorkspace>(MockBehavior.Strict).Object, dbConnectionMock.Object, true, true); Assert.Equal(ConnectionState.Open, entityConnection.State); Assert.Equal(ConnectionState.Open, entityConnection.StoreConnection.State); entityConnection.OpenAsync().Wait(); dbConnectionMock.Verify(m => m.Close(), Times.Never()); Assert.Equal(ConnectionState.Open, entityConnection.State); Assert.Equal(ConnectionState.Open, entityConnection.StoreConnection.State); }
public void Exception_is_thrown_when_trying_to_open_a_broken_connection() { var dbConnectionMock = new Mock<DbConnection>(MockBehavior.Strict); dbConnectionMock.SetupGet(m => m.State).Returns(ConnectionState.Broken); dbConnectionMock.SetupGet(m => m.DataSource).Returns(() => "fake"); var metadataWorkspace = CreateMetadataWorkspaceMock().Object; var entityConnection = new EntityConnection(metadataWorkspace, dbConnectionMock.Object, true, true); Assert.Equal( Strings.EntityClient_CannotOpenBrokenConnection, Assert.Throws<InvalidOperationException>( () => ExceptionHelpers.UnwrapAggregateExceptions( () => entityConnection.OpenAsync().Wait())).Message); }
public void Exception_is_thrown_when_store_connection_doesnt_open() { var storeConnectionState = ConnectionState.Closed; var storeConnectionMock = new Mock<DbConnection>(); storeConnectionMock.Setup(m => m.Close()).Callback(() => storeConnectionState = ConnectionState.Closed); storeConnectionMock.Setup(m => m.OpenAsync(It.IsAny<CancellationToken>())).Returns(Task.FromResult(true)); storeConnectionMock.SetupGet(m => m.DataSource).Returns("fake"); storeConnectionMock.SetupGet(m => m.State).Returns(() => storeConnectionState); var entityConnection = new EntityConnection(CreateMetadataWorkspaceMock().Object, storeConnectionMock.Object, true, true); Assert.Equal( Strings.EntityClient_ConnectionNotOpen, Assert.Throws<InvalidOperationException>( () => ExceptionHelpers.UnwrapAggregateExceptions( () => entityConnection.OpenAsync().Wait())).Message); }
public void StoreConnection_state_mimics_EntityConnection_state_if_only_EntityConnection_is_used_without_txn() { var storeConnectionState = ConnectionState.Closed; var storeConnectionMock = new Mock<DbConnection>(MockBehavior.Strict); storeConnectionMock.Setup(m => m.OpenAsync(It.IsAny<CancellationToken>())).Callback( () => storeConnectionState = ConnectionState.Open).Returns(Task.FromResult(1)); storeConnectionMock.Setup(m => m.Close()).Callback(() => storeConnectionState = ConnectionState.Closed); storeConnectionMock.SetupGet(m => m.State).Returns(() => storeConnectionState); storeConnectionMock.SetupGet(m => m.DataSource).Returns("fake"); var entityConnection = new EntityConnection(CreateMetadataWorkspaceMock().Object, storeConnectionMock.Object, true, true); Assert.Equal(ConnectionState.Closed, entityConnection.State); // entityConnection state Assert.Equal(ConnectionState.Closed, entityConnection.StoreConnection.State); // underlying storeConnection state // open entityConnection (automatically opens store connection) entityConnection.OpenAsync().Wait(); storeConnectionMock.Raise( conn => conn.StateChange += null, new StateChangeEventArgs(ConnectionState.Closed, ConnectionState.Open)); Assert.Equal(ConnectionState.Open, entityConnection.State); // entityConnection state Assert.Equal(ConnectionState.Open, entityConnection.StoreConnection.State); // underlying storeConnection state // close entityConnection without explicitly closing underlying store connection entityConnection.Close(); storeConnectionMock.Raise( conn => conn.StateChange -= null, new StateChangeEventArgs(ConnectionState.Open, ConnectionState.Closed)); Assert.Equal(ConnectionState.Closed, entityConnection.State); // entityConnection state Assert.Equal(ConnectionState.Closed, entityConnection.StoreConnection.State); // underlying storeConnection state }
public void EntityConnection_with_closed_underlying_connection_maintains_closed_if_store_connection_does_not_open_correctly() { var dbConnectionMock = new Mock<DbConnection>(MockBehavior.Strict); dbConnectionMock.Setup(m => m.OpenAsync(It.IsAny<CancellationToken>())).Returns( Task.FromResult(1)); dbConnectionMock.Setup(m => m.Close()).Verifiable(); dbConnectionMock.SetupGet(m => m.State).Returns(ConnectionState.Closed); dbConnectionMock.SetupGet(m => m.DataSource).Returns("fake"); var entityConnection = new EntityConnection(CreateMetadataWorkspaceMock().Object, dbConnectionMock.Object, true, true); Assert.Equal( Strings.EntityClient_ConnectionNotOpen, Assert.Throws<InvalidOperationException>( () => ExceptionHelpers.UnwrapAggregateExceptions( () => entityConnection.OpenAsync().Wait())).Message); Assert.Equal(ConnectionState.Closed, entityConnection.State); }
public void Should_use_interception() { var mockConnection = new Mock<DbConnection>(); mockConnection.SetupGet(m => m.DataSource).Returns("Foo"); mockConnection.SetupGet(m => m.State).Returns(ConnectionState.Closed); var mockStoreItemCollection = new Mock<StoreItemCollection>(); mockStoreItemCollection .SetupGet(m => m.ProviderFactory) .Returns(DbProviderServices.GetProviderFactory(new SqlConnection())); var mockMetadataWorkspace = new Mock<MetadataWorkspace>(); mockMetadataWorkspace .Setup(m => m.GetItemCollection(DataSpace.SSpace)) .Returns(mockStoreItemCollection.Object); var objectContext = new ObjectContext(); var mockConnectionInterceptor = new Mock<IDbConnectionInterceptor>(); mockConnectionInterceptor .Setup(m => m.Opening(mockConnection.Object, It.IsAny<DbConnectionInterceptionContext>())) .Callback<DbConnection, MutableInterceptionContext>( (_, c) => Assert.Equal(new[] { objectContext }, c.ObjectContexts)); mockConnectionInterceptor .Setup(m => m.Opened(mockConnection.Object, It.IsAny<DbConnectionInterceptionContext>())) .Callback<DbConnection, MutableInterceptionContext>( (_, c) => mockConnection.Verify(m => m.OpenAsync(It.IsAny<CancellationToken>()), Times.Once())); mockConnection .Setup(m => m.OpenAsync(It.IsAny<CancellationToken>())) .Returns( () => { mockConnection .SetupGet(m => m.State).Returns(ConnectionState.Open); mockConnection.Raise( m => m.StateChange += null, new StateChangeEventArgs(ConnectionState.Closed, ConnectionState.Open)); return Task.FromResult(true); }); EntityConnection connection; DbInterception.Add(mockConnectionInterceptor.Object); try { connection = new EntityConnection( mockMetadataWorkspace.Object, mockConnection.Object, true, true); connection.AssociateContext(objectContext); connection.OpenAsync().Wait(); } finally { DbInterception.Remove(mockConnectionInterceptor.Object); } mockConnectionInterceptor.Verify(m => m.Opening(mockConnection.Object, It.IsAny<DbConnectionInterceptionContext>()), Times.Once()); mockConnectionInterceptor.Verify(m => m.Opened(mockConnection.Object, It.IsAny<DbConnectionInterceptionContext>()), Times.Once()); mockConnectionInterceptor .Verify(m => m.Opened(mockConnection.Object, It.IsAny<DbConnectionInterceptionContext>()), Times.Once()); mockConnectionInterceptor.Verify( m => m.StateGetting(It.IsAny<DbConnection>(), It.IsAny<DbConnectionInterceptionContext<ConnectionState>>()), Times.Exactly(3)); mockConnectionInterceptor.Verify( m => m.StateGot(It.IsAny<DbConnection>(), It.IsAny<DbConnectionInterceptionContext<ConnectionState>>()), Times.Exactly(3)); mockConnection.Verify(m => m.State, Times.Exactly(3)); Assert.Equal(ConnectionState.Open, connection.State); }
public void ExecutionStrategy_is_used() { var storeConnectionState = ConnectionState.Closed; var storeConnectionMock = new Mock<DbConnection>(MockBehavior.Strict); storeConnectionMock.Setup(m => m.OpenAsync(It.IsAny<CancellationToken>())).Returns( () => { storeConnectionState = ConnectionState.Open; return Task.FromResult(true); }); storeConnectionMock.SetupGet(m => m.DataSource).Returns("fake"); storeConnectionMock.SetupGet(m => m.State).Returns(() => storeConnectionState); var entityConnection = new EntityConnection(CreateMetadataWorkspaceMock().Object, storeConnectionMock.Object, true, true); var executionStrategyMock = new Mock<IDbExecutionStrategy>(); executionStrategyMock.Setup(m => m.ExecuteAsync(It.IsAny<Func<Task>>(), It.IsAny<CancellationToken>())) .Returns<Func<Task>, CancellationToken>( (f, c) => { storeConnectionMock.Verify(m => m.OpenAsync(It.IsAny<CancellationToken>()), Times.Never()); f().Wait(); storeConnectionMock.Verify(m => m.OpenAsync(It.IsAny<CancellationToken>()), Times.Once()); return Task.FromResult(true); }); MutableResolver.AddResolver<Func<IDbExecutionStrategy>>(key => (Func<IDbExecutionStrategy>)(() => executionStrategyMock.Object)); try { entityConnection.OpenAsync().Wait(); } finally { MutableResolver.ClearResolvers(); } executionStrategyMock.Verify(m => m.ExecuteAsync(It.IsAny<Func<Task>>(), It.IsAny<CancellationToken>()), Times.Once()); }
public void OpenAsync_checks_connection_before_checking_for_cancellation() { // InvalidOperationException(Strings.EntityClient_ConnectionStringNeededBeforeOperation); Assert.Equal( Strings.EntityClient_ConnectionStringNeededBeforeOperation, Assert.Throws<InvalidOperationException>( () => new EntityConnection().OpenAsync(new CancellationToken(canceled: true)) .GetAwaiter().GetResult()).Message); var mockDbConnection = new Mock<DbConnection>(); mockDbConnection.Setup(c => c.State).Returns(ConnectionState.Broken); var entityConnection = new EntityConnection( /* metadataWorkspace */ null, mockDbConnection.Object, /* skipInitialization */ true, false); Assert.Equal( Strings.EntityClient_CannotOpenBrokenConnection, Assert.Throws<InvalidOperationException>( () => entityConnection.OpenAsync(new CancellationToken(canceled: true)) .GetAwaiter().GetResult()).Message); }
public void EntityConnection_automatically_closed_if_underlying_StoreConnection_is_closed_without_txn() { var storeConnectionState = ConnectionState.Closed; var storeConnectionMock = new Mock<DbConnection>(MockBehavior.Strict); storeConnectionMock.Setup(m => m.OpenAsync(It.IsAny<CancellationToken>())).Callback( () => storeConnectionState = ConnectionState.Open).Returns(Task.FromResult(1)); storeConnectionMock.Setup(m => m.Close()).Callback(() => storeConnectionState = ConnectionState.Closed); storeConnectionMock.SetupGet(m => m.State).Returns(() => storeConnectionState); storeConnectionMock.SetupGet(m => m.DataSource).Returns("fake"); // open entityConnection - both entityConnection and store connection should now be open var entityConnection = new EntityConnection(CreateMetadataWorkspaceMock().Object, storeConnectionMock.Object, true, true); entityConnection.OpenAsync().Wait(); storeConnectionMock.Raise( conn => conn.StateChange += null, new StateChangeEventArgs(ConnectionState.Closed, ConnectionState.Open)); Assert.Equal(ConnectionState.Open, entityConnection.State); // entityConnection state Assert.Equal(ConnectionState.Open, entityConnection.StoreConnection.State); // underlying storeConnection state // now close the underlying store connection without explicitly closing entityConnection entityConnection.StoreConnection.Close(); storeConnectionMock.Raise( conn => conn.StateChange -= null, new StateChangeEventArgs(ConnectionState.Open, ConnectionState.Closed)); Assert.Equal(ConnectionState.Closed, entityConnection.State); // entityConnection state automatically updated Assert.Equal(ConnectionState.Closed, entityConnection.StoreConnection.State); // now re-open the store connection and EntityConnection is "resurrected" to an Open state entityConnection.StoreConnection.OpenAsync().Wait(); storeConnectionMock.Raise( conn => conn.StateChange += null, new StateChangeEventArgs(ConnectionState.Closed, ConnectionState.Open)); Assert.Equal(ConnectionState.Open, entityConnection.State); Assert.Equal(ConnectionState.Open, entityConnection.StoreConnection.State); }
public void Underlying_dbConnection_is_not_being_closed_if_it_was_initially_open_such_that_it_cannot_be_reopend() { var dbConnectionMock = new Mock<DbConnection>(MockBehavior.Strict); dbConnectionMock.Setup(m => m.OpenAsync(It.IsAny<CancellationToken>())).Returns(Task.FromResult(1)); dbConnectionMock.Setup(m => m.Close()).Verifiable(); dbConnectionMock.SetupGet(m => m.State).Returns(ConnectionState.Open); dbConnectionMock.SetupGet(m => m.DataSource).Returns("fake"); var entityConnection = new EntityConnection( new Mock<MetadataWorkspace>(MockBehavior.Strict).Object, dbConnectionMock.Object, true, true); Assert.Equal(ConnectionState.Open, entityConnection.State); Assert.Equal(ConnectionState.Open, entityConnection.StoreConnection.State); Assert.Equal( Strings.EntityClient_CannotReopenConnection, Assert.Throws<InvalidOperationException>( () => ExceptionHelpers.UnwrapAggregateExceptions( () => entityConnection.OpenAsync().Wait())).Message); dbConnectionMock.Verify(m => m.Close(), Times.Never()); Assert.Equal(ConnectionState.Open, entityConnection.State); Assert.Equal(ConnectionState.Open, entityConnection.StoreConnection.State); }