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);
}
