public virtual EntityConnectionProxy CreateNew(DbConnection storeConnection)
{
var clonedConnection = new EntityConnection(_entityConnection.GetMetadataWorkspace(), storeConnection);
var currentTransaction = _entityConnection.CurrentTransaction;
if (currentTransaction != null
&& DbInterception.Dispatch.Transaction.GetConnection(
currentTransaction.StoreTransaction, _entityConnection.InterceptionContext) == storeConnection)
{
clonedConnection.UseStoreTransaction(currentTransaction.StoreTransaction);
}
return new EntityConnectionProxy(clonedConnection);
}
public void Passing_a_valid_transaction_to_UseStoreTransaction_sets_CurrentTransaction()
{
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, true);
var dbTransactionMock = new Mock<DbTransaction>();
dbTransactionMock.Protected().SetupGet<DbConnection>("DbConnection").Returns(() => dbConnectionMock.Object);
entityConnection.UseStoreTransaction(dbTransactionMock.Object);
Assert.Equal(dbTransactionMock.Object, entityConnection.CurrentTransaction.StoreTransaction);
}
public void Passing_a_transaction_from_a_different_connection_to_UseStoreTransaction_throws_InvalidOperationException()
{
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, true);
// set up a transaction from a different underlying store connection
var otherDbConnectionMock = new Mock<DbConnection>(MockBehavior.Strict);
otherDbConnectionMock.SetupGet(m => m.State).Returns(() => ConnectionState.Open);
var otherDbTransactionMock = new Mock<DbTransaction>();
otherDbTransactionMock.Protected().SetupGet<DbConnection>("DbConnection").Returns(() => otherDbConnectionMock.Object);
Assert.Equal(
Strings.DbContext_InvalidTransactionForConnection,
Assert.Throws<InvalidOperationException>(() => entityConnection.UseStoreTransaction(otherDbTransactionMock.Object))
.Message);
}
Passing_a_transaction_to_UseStoreTransaction_when_it_is_already_enlisted_in_a_TransactionScope_Transaction_throws_InvalidOperationException()
{
var dbConnectionMock = new Mock<DbConnection>(MockBehavior.Strict);
dbConnectionMock.SetupGet(m => m.State).Returns(() => ConnectionState.Open);
dbConnectionMock.Setup(m => m.EnlistTransaction(It.IsAny<Transaction>())).Verifiable();
var metadataWorkspaceMock = new Mock<MetadataWorkspace>(MockBehavior.Strict);
metadataWorkspaceMock.Setup(m => m.IsItemCollectionAlreadyRegistered(DataSpace.SSpace)).Returns(true);
using (new TransactionScope())
{
var entityConnection = new EntityConnection(metadataWorkspaceMock.Object, dbConnectionMock.Object, true, true);
entityConnection.EnlistTransaction(Transaction.Current);
var dbTransactionMock = new Mock<DbTransaction>();
dbTransactionMock.Protected().SetupGet<DbConnection>("DbConnection").Returns(() => dbConnectionMock.Object);
Assert.Equal(
Strings.DbContext_TransactionAlreadyEnlistedInUserTransaction,
Assert.Throws<InvalidOperationException>(() => entityConnection.UseStoreTransaction(dbTransactionMock.Object))
.Message);
}
}
public void Passing_null_to_UseStoreTransaction_on_EntityConnection_Clears_Current_Transaction()
{
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);
// note: entityConnection will already appear open to mock transaction since underlying connection is open
var entityConnection = new EntityConnection(metadataWorkspaceMock.Object, dbConnectionMock.Object, true, true);
var dbTransactionMock = new Mock<DbTransaction>();
dbTransactionMock.Protected().SetupGet<DbConnection>("DbConnection").Returns(() => entityConnection.StoreConnection);
entityConnection.UseStoreTransaction(dbTransactionMock.Object);
Assert.NotNull(entityConnection.CurrentTransaction);
entityConnection.UseStoreTransaction(null);
Assert.Null(entityConnection.CurrentTransaction);
}
public void Should_use_interception()
{
var mockWorkspace = CreateMetadataWorkspaceMock();
var dbConnectionMock = new Mock<DbConnection>(MockBehavior.Strict);
dbConnectionMock.Setup(m => m.State).Returns(ConnectionState.Open);
dbConnectionMock.Setup(m => m.ConnectionTimeout).Returns(666);
dbConnectionMock.Setup(m => m.ToString()).Returns("Mock Connection");
dbConnectionMock.Protected()
.Setup<DbProviderFactory>("DbProviderFactory")
.Returns(GenericProviderFactory<DbProviderFactory>.Instance);
var transactionMock = new Mock<DbTransaction>();
transactionMock.Protected().Setup<DbConnection>("DbConnection").Returns(dbConnectionMock.Object);
var dbConnectionInterceptorMock = new Mock<IDbConnectionInterceptor>();
DbInterception.Add(dbConnectionInterceptorMock.Object);
var transactionInterceptorMock = new Mock<IDbTransactionInterceptor>();
DbInterception.Add(transactionInterceptorMock.Object);
try
{
var connection = new EntityConnection(mockWorkspace.Object, dbConnectionMock.Object, false, true);
connection.UseStoreTransaction(transactionMock.Object);
Assert.Same(transactionMock.Object, connection.CurrentTransaction.StoreTransaction);
}
finally
{
DbInterception.Remove(dbConnectionInterceptorMock.Object);
DbInterception.Remove(transactionInterceptorMock.Object);
}
dbConnectionInterceptorMock.Verify(
m => m.StateGetting(It.IsAny<DbConnection>(), It.IsAny<DbConnectionInterceptionContext<ConnectionState>>()),
Times.Once());
dbConnectionInterceptorMock.Verify(
m => m.StateGot(It.IsAny<DbConnection>(), It.IsAny<DbConnectionInterceptionContext<ConnectionState>>()),
Times.Once());
dbConnectionMock.Verify(m => m.State, Times.Once());
transactionInterceptorMock.Verify(
m => m.ConnectionGetting(It.IsAny<DbTransaction>(), It.IsAny<DbTransactionInterceptionContext<DbConnection>>()),
Times.Exactly(2));
transactionInterceptorMock.Verify(
m => m.ConnectionGot(It.IsAny<DbTransaction>(), It.IsAny<DbTransactionInterceptionContext<DbConnection>>()),
Times.Exactly(2));
transactionMock.Protected().Verify<DbConnection>("DbConnection",Times.Exactly(2));
}
