public WhenCallingCommit()
{
this.mockConnection.Setup(x => x.BeginTransaction(It.IsAny<IsolationLevel>())).Returns(this.mockTransaction.Object);
this.mockSessionBase.Setup(x => x.Connection).Returns(this.mockConnection.Object);
this.transaction = new Transaction(this.mockSessionBase.Object, IsolationLevel.ReadCommitted);
this.transaction.Commit();
}
public WhenCallingCommit_AndTheTransactionHasBeenCommitted()
{
var mockConnection = new Mock<IDbConnection>();
mockConnection.Setup(x => x.BeginTransaction(It.IsAny<IsolationLevel>())).Returns(new Mock<IDbTransaction>().Object);
var mockSessionBase = new Mock<ISessionBase>();
mockSessionBase.Setup(x => x.Connection).Returns(mockConnection.Object);
this.transaction = new Transaction(mockSessionBase.Object, IsolationLevel.ReadCommitted);
transaction.Commit();
}
public void DisposeDoesNotThrowAnExceptionIfCalledTwice()
{
var mockConnection = new Mock<IDbConnection>();
mockConnection.Setup(x => x.BeginTransaction(It.IsAny<IsolationLevel>())).Returns(new Mock<IDbTransaction>().Object);
var mockSessionBase = new Mock<ISessionBase>();
mockSessionBase.Setup(x => x.Connection).Returns(mockConnection.Object);
var transaction = new Transaction(mockSessionBase.Object, IsolationLevel.ReadCommitted);
transaction.Commit();
transaction.Dispose();
Assert.DoesNotThrow(() => transaction.Dispose());
}
public ITransaction BeginTransaction(IsolationLevel isolationLevel)
{
this.ThrowIfDisposed();
if (this.ConnectionScope == ConnectionScope.PerTransaction)
{
if (Log.IsDebug)
{
Log.Debug(LogMessages.OpeningConnection);
}
this.Connection.Open();
}
this.currentTransaction = new Transaction(this, isolationLevel);
return this.currentTransaction;
}
public void DisposeShouldNotThrowAnExceptionIfRollingBackAnUncommittedTransactionAndRollbackThrowsAnException()
{
var mockTransaction = new Mock<IDbTransaction>();
mockTransaction.Setup(x => x.Commit()).Throws<InvalidOperationException>();
mockTransaction.Setup(x => x.Rollback()).Throws<InvalidOperationException>();
var mockConnection = new Mock<IDbConnection>();
mockConnection.Setup(x => x.BeginTransaction(It.IsAny<IsolationLevel>())).Returns(mockTransaction.Object);
var mockSessionBase = new Mock<ISessionBase>();
mockSessionBase.Setup(x => x.Connection).Returns(mockConnection.Object);
var transaction = new Transaction(mockSessionBase.Object, IsolationLevel.ReadCommitted);
try
{
transaction.Commit();
}
catch
{
}
Assert.DoesNotThrow(() => transaction.Dispose());
}
public WhenConstructed()
{
this.mockSessionBase.Setup(x => x.Connection).Returns(this.mockConnection.Object);
this.transaction = new Transaction(this.mockSessionBase.Object, this.isolationLevel);
}
public WhenCallingRollback_AndTheTransactionThrowsAnException()
{
this.mockTransaction.Setup(x => x.Rollback()).Throws<InvalidOperationException>();
this.mockConnection.Setup(x => x.BeginTransaction(It.IsAny<IsolationLevel>())).Returns(this.mockTransaction.Object);
this.mockSessionBase.Setup(x => x.Connection).Returns(this.mockConnection.Object);
this.transaction = new Transaction(this.mockSessionBase.Object, IsolationLevel.ReadCommitted);
this.exception = Assert.Throws<MicroLiteException>(() => this.transaction.Rollback());
}
public WhenCallingEnlist()
{
var mockConnection = new Mock<IDbConnection>();
mockConnection.Setup(x => x.BeginTransaction(It.IsAny<IsolationLevel>())).Returns(this.mockTransaction.Object);
mockConnection.Setup(x => x.CreateCommand()).Returns(this.mockCommand.Object);
var mockSessionBase = new Mock<ISessionBase>();
mockSessionBase.Setup(x => x.Connection).Returns(mockConnection.Object);
this.transaction = new Transaction(mockSessionBase.Object, IsolationLevel.ReadCommitted);
this.transaction.Enlist(this.mockCommand.Object);
}
public WhenCallingDispose_AndTheTransactionHasNotBeenCommitted()
{
this.mockConnection.Setup(x => x.BeginTransaction(It.IsAny<IsolationLevel>())).Returns(this.mockTransaction.Object);
this.mockSessionBase.Setup(x => x.Connection).Returns(this.mockConnection.Object);
var transaction = new Transaction(this.mockSessionBase.Object, IsolationLevel.ReadCommitted);
transaction.Dispose();
}
public WhenCallingDispose_AndTheTransactionHasFailed_AndHasNotBeenRolledBack()
{
this.mockTransaction.Setup(x => x.Commit()).Throws<InvalidOperationException>();
this.mockConnection.Setup(x => x.BeginTransaction(It.IsAny<IsolationLevel>())).Returns(this.mockTransaction.Object);
this.mockSessionBase.Setup(x => x.Connection).Returns(this.mockConnection.Object);
var transaction = new Transaction(this.mockSessionBase.Object, IsolationLevel.ReadCommitted);
Assert.Throws<MicroLiteException>(() => transaction.Commit());
transaction.Dispose();
}
public void TransactionCompleted()
{
if (this.ConnectionScope == ConnectionScope.PerTransaction)
{
if (Log.IsDebug)
{
Log.Debug(LogMessages.ClosingConnection);
}
this.Connection.Close();
}
this.currentTransaction = null;
}
protected void Dispose(bool disposing)
{
if (this.disposed)
{
return;
}
if (disposing)
{
this.disposed = true;
if (this.currentTransaction != null)
{
this.currentTransaction.Dispose();
this.currentTransaction = null;
}
if (this.ConnectionScope == ConnectionScope.PerSession)
{
if (this.Connection != null)
{
if (Log.IsDebug)
{
Log.Debug(LogMessages.ClosingConnection);
}
this.Connection.Close();
}
}
if (this.Connection != null)
{
this.Connection.Dispose();
this.Connection = null;
}
}
}
