public void Open_should_dispatch_and_optionally_open_underlying_connection()
{
var mockConnection = new Mock<DbConnection>();
mockConnection.SetupGet(m => m.DataSource).Returns("Foo");
var dispatcher = new EntityConnectionDispatcher();
var mockConnectionInterceptor = new Mock<IEntityConnectionInterceptor>();
dispatcher.InternalDispatcher.Add(mockConnectionInterceptor.Object);
var mockStoreItemCollection = new Mock<StoreItemCollection>();
mockStoreItemCollection
.SetupGet(m => m.StoreProviderFactory)
.Returns(DbProviderServices.GetProviderFactory(new SqlConnection()));
var mockMetadataWorkspace = new Mock<MetadataWorkspace>();
mockMetadataWorkspace
.Setup(m => m.GetItemCollection(DataSpace.SSpace))
.Returns(mockStoreItemCollection.Object);
var connection
= new EntityConnection(
mockMetadataWorkspace.Object,
mockConnection.Object,
true,
true,
dispatcher);
var objectContext = new ObjectContext();
connection.AssociateContext(objectContext);
mockConnectionInterceptor
.Setup(m => m.ConnectionOpening(connection, It.IsAny<DbInterceptionContext>()))
.Callback<EntityConnection, DbInterceptionContext>(
(_, c) => Assert.Equal(new[] { objectContext }, c.ObjectContexts))
.Returns(false);
connection.Open();
mockConnection.Verify(m => m.Open(), Times.Never());
Assert.Equal(ConnectionState.Open, connection.State);
mockConnectionInterceptor
.Setup(m => m.ConnectionOpening(connection, It.IsAny<DbInterceptionContext>()))
.Callback<EntityConnection, DbInterceptionContext>(
(_, c) => Assert.Equal(new[] { objectContext }, c.ObjectContexts))
.Returns(true);
mockConnection
.Setup(m => m.Open())
.Callback(
() => mockConnection
.SetupGet(m => m.State).Returns(ConnectionState.Open)
.Raises(
m => m.StateChange += null,
new StateChangeEventArgs(ConnectionState.Closed, ConnectionState.Open)));
connection.Open();
mockConnection.Verify(m => m.Open(), Times.Once());
Assert.Equal(ConnectionState.Open, connection.State);
}
public void Associating_the_same_ObjectContext_twice_does_not_result_in_duplicate_entries()
{
var connection = new EntityConnection();
var context = new ObjectContext();
connection.AssociateContext(context);
connection.AssociateContext(context);
Assert.Equal(new[] { context }, connection.AssociatedContexts);
}
public void A_disposed_ObjectContext_is_unassociated_when_a_new_ObjectContext_is_associated()
{
var connection = new EntityConnection();
var context1 = new ObjectContext();
connection.AssociateContext(context1);
context1.Dispose();
var context2 = new ObjectContext();
connection.AssociateContext(context2);
Assert.Equal(new[] { context2 }, connection.AssociatedContexts);
}
public void Contexts_can_be_associated_with_an_EntityConnection()
{
var connection = new EntityConnection();
var contexts = new[]
{
new ObjectContext(),
new ObjectContext(),
new ObjectContext(),
};
connection.AssociateContext(contexts[0]);
Assert.Equal(new[] { contexts[0] }, connection.AssociatedContexts);
connection.AssociateContext(contexts[1]);
connection.AssociateContext(contexts[2]);
foreach (var context in contexts)
{
Assert.Contains(context, connection.AssociatedContexts);
}
}
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, DbConnectionInterceptionContext>(
(_, c) => Assert.Equal(new[] { objectContext }, c.ObjectContexts));
mockConnectionInterceptor
.Setup(m => m.Opened(mockConnection.Object, It.IsAny<DbConnectionInterceptionContext>()))
.Callback<DbConnection, DbConnectionInterceptionContext>(
(_, c) => mockConnection.Verify(m => m.Open(), Times.Once()));
mockConnection
.Setup(m => m.Open())
.Callback(
() =>
{
mockConnection
.SetupGet(m => m.State).Returns(ConnectionState.Open);
mockConnection.Raise(
m => m.StateChange += null, new StateChangeEventArgs(ConnectionState.Closed, ConnectionState.Open));
});
EntityConnection connection;
DbInterception.Add(mockConnectionInterceptor.Object);
try
{
connection
= new EntityConnection(
mockMetadataWorkspace.Object,
mockConnection.Object,
true,
true);
connection.AssociateContext(objectContext);
connection.Open();
}
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 Should_use_interception()
{
var mockConnection = new Mock<DbConnection>();
mockConnection.SetupGet(m => m.DataSource).Returns("Foo");
mockConnection.SetupGet(m => m.State).Returns(ConnectionState.Open);
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 mockTransaction = new Mock<DbTransaction>();
var mockConnectionInterceptor = new Mock<IDbConnectionInterceptor>();
mockConnectionInterceptor
.Setup(m => m.BeginningTransaction(mockConnection.Object, It.IsAny<BeginTransactionInterceptionContext>()))
.Callback<DbConnection, BeginTransactionInterceptionContext>(
(_, c) =>
{
Assert.Equal(new[] { objectContext }, c.ObjectContexts);
Assert.Equal(IsolationLevel.Chaos, c.IsolationLevel);
});
mockConnectionInterceptor
.Setup(m => m.BeganTransaction(mockConnection.Object, It.IsAny<BeginTransactionInterceptionContext>()))
.Callback<DbConnection, BeginTransactionInterceptionContext>(
(_, c) =>
{
Assert.Equal(new[] { objectContext }, c.ObjectContexts);
Assert.Equal(IsolationLevel.Chaos, c.IsolationLevel);
Assert.Same(mockTransaction.Object, c.Result);
});
mockConnection
.Protected()
.Setup<DbTransaction>("BeginDbTransaction", ItExpr.IsAny<IsolationLevel>())
.Returns(mockTransaction.Object);
EntityConnection connection;
DbInterception.Add(mockConnectionInterceptor.Object);
try
{
connection
= new EntityConnection(
mockMetadataWorkspace.Object,
mockConnection.Object,
true,
true);
connection.AssociateContext(objectContext);
connection.BeginTransaction(IsolationLevel.Chaos);
}
finally
{
DbInterception.Remove(mockConnectionInterceptor.Object);
}
mockConnectionInterceptor.Verify(
m => m.BeginningTransaction(mockConnection.Object, It.IsAny<BeginTransactionInterceptionContext>()), Times.Once());
mockConnectionInterceptor.Verify(
m => m.BeganTransaction(mockConnection.Object, It.IsAny<BeginTransactionInterceptionContext>()), Times.Once());
mockConnection
.Protected()
.Verify<DbTransaction>("BeginDbTransaction", Times.Once(), ItExpr.IsAny<IsolationLevel>());
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);
}
