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