public void ShouldCloseInnerConnection()
{
Mock <DbConnection> dbConnectionMock = new Mock <DbConnection>();
Mock <ISyncPolicy> retryPolicyMock = new Mock <ISyncPolicy>();
var connectionWrapper = new ReliableDbConnectionWrapper(dbConnectionMock.Object, retryPolicyMock.Object);
connectionWrapper.Close();
dbConnectionMock.Verify(x => x.Close());
}
public void ShouldSetConnectionStringToInnerConnection()
{
string testConnectionString = fixture.Create <string>();
Mock <DbConnection> dbConnectionMock = new Mock <DbConnection>();
Mock <ISyncPolicy> retryPolicyMock = new Mock <ISyncPolicy>();
var connectionWrapper = new ReliableDbConnectionWrapper(dbConnectionMock.Object, retryPolicyMock.Object);
connectionWrapper.ConnectionString = testConnectionString;
dbConnectionMock.VerifySet(x => x.ConnectionString = testConnectionString);
}
public void ShouldCloseAndDisposeInnerConnection()
{
var dbConnectionMock = new MockDbConnection();
Mock <ISyncPolicy> retryPolicyMock = new Mock <ISyncPolicy>();
var connectionWrapper = new ReliableDbConnectionWrapper(dbConnectionMock, retryPolicyMock.Object);
connectionWrapper.Dispose();
Assert.Equal(1, ((MockDbConnection)connectionWrapper.InnerConnection).CloseCount);
Assert.Equal(1, ((MockDbConnection)connectionWrapper.InnerConnection).DisposeCount);
}
public void ShouldSetNewDatabaseToInnerConnection()
{
string testDatabasename = fixture.Create <string>();
Mock <DbConnection> dbConnectionMock = new Mock <DbConnection>();
Mock <ISyncPolicy> retryPolicyMock = new Mock <ISyncPolicy>();
var connectionWrapper = new ReliableDbConnectionWrapper(dbConnectionMock.Object, retryPolicyMock.Object);
connectionWrapper.ChangeDatabase(testDatabasename);
dbConnectionMock.Verify(x => x.ChangeDatabase(testDatabasename));
}
public void ShouldReadConnectionStateFromInnerConnection()
{
ConnectionState testConnectionState = fixture.Create <ConnectionState>();
Mock <DbConnection> dbConnectionMock = new Mock <DbConnection>();
Mock <ISyncPolicy> retryPolicyMock = new Mock <ISyncPolicy>();
dbConnectionMock.Setup(x => x.State).Returns(testConnectionState);
var connectionWrapper = new ReliableDbConnectionWrapper(dbConnectionMock.Object, retryPolicyMock.Object);
Assert.Equal(testConnectionState, connectionWrapper.State);
}
public void ShouldReadServerVersionFromInnerConnection()
{
string testServerVersion = fixture.Create <string>();
Mock <DbConnection> dbConnectionMock = new Mock <DbConnection>();
Mock <ISyncPolicy> retryPolicyMock = new Mock <ISyncPolicy>();
dbConnectionMock.Setup(x => x.ServerVersion).Returns(testServerVersion);
var connectionWrapper = new ReliableDbConnectionWrapper(dbConnectionMock.Object, retryPolicyMock.Object);
Assert.Equal(testServerVersion, connectionWrapper.ServerVersion);
}
public void ShouldReadDataSourceFromInnerConnection()
{
string testDataSource = fixture.Create <string>();
Mock <DbConnection> dbConnectionMock = new Mock <DbConnection>();
Mock <ISyncPolicy> retryPolicyMock = new Mock <ISyncPolicy>();
dbConnectionMock.Setup(x => x.DataSource).Returns(testDataSource);
var connectionWrapper = new ReliableDbConnectionWrapper(dbConnectionMock.Object, retryPolicyMock.Object);
Assert.Equal(testDataSource, connectionWrapper.DataSource);
}
public void ShouldCreateCommandsInInnerConnectionAnReturnWrapper()
{
var dbConnectionMock = new MockDbConnection();
Mock <ISyncPolicy> retryPolicyMock = new Mock <ISyncPolicy>();
var connectionWrapper = new ReliableDbConnectionWrapper(dbConnectionMock, retryPolicyMock.Object);
var obtainedCommand = connectionWrapper.CreateCommand();
Assert.Equal(1, ((MockDbConnection)connectionWrapper.InnerConnection).CreateCommandCount);
Assert.True(obtainedCommand is ReliableDbCommandWrapper);
}
public void ShouldNotOpenInnerConnectionWhenAlreadyOpen()
{
Mock <DbConnection> dbConnectionMock = new Mock <DbConnection>();
Mock <ISyncPolicy> retryPolicyMock = new Mock <ISyncPolicy>();
var connectionWrapper = new ReliableDbConnectionWrapper(dbConnectionMock.Object, retryPolicyMock.Object);
dbConnectionMock.Setup(x => x.State).Returns(ConnectionState.Open);
connectionWrapper.Open();
dbConnectionMock.Verify(x => x.Open(), Times.Never);
}
public void ShouldReturnConnectionGivenOnConstruction()
{
Mock <DbConnection> dbConnectionMock = new Mock <DbConnection>();
Mock <DbTransaction> dbTransactionMock = new Mock <DbTransaction>();
Mock <ISyncPolicy> retryPolicyMock = new Mock <ISyncPolicy>();
ReliableDbConnectionWrapper connectionWrapper = new ReliableDbConnectionWrapper(dbConnectionMock.Object, retryPolicyMock.Object);
var transactionWrapper = new ReliableDbTransactionWrapper(dbTransactionMock.Object, connectionWrapper, retryPolicyMock.Object);
Assert.Equal(connectionWrapper, transactionWrapper.Connection);
}
public void ShouldDisposeInnerTransaction()
{
Mock <DbConnection> dbConnectionMock = new Mock <DbConnection>();
MockDbTransaction dbTransactionMock = new MockDbTransaction();
Mock <ISyncPolicy> retryPolicyMock = new Mock <ISyncPolicy>();
ReliableDbConnectionWrapper connectionWrapper = new ReliableDbConnectionWrapper(dbConnectionMock.Object, retryPolicyMock.Object);
var transactionWrapper = new ReliableDbTransactionWrapper(dbTransactionMock, connectionWrapper, retryPolicyMock.Object);
transactionWrapper.Dispose();
Assert.Equal(1, dbTransactionMock.DisposalCount);
}
public void ShouldOpenInnerConnectionWithRetriesWhenInStatusOtherThanOpen()
{
Mock <DbConnection> dbConnectionMock = new Mock <DbConnection>();
Mock <ISyncPolicy> retryPolicyMock = new Mock <ISyncPolicy>();
var connectionWrapper = new ReliableDbConnectionWrapper(dbConnectionMock.Object, retryPolicyMock.Object);
dbConnectionMock.Setup(x => x.State).Returns(ConnectionState.Closed);
retryPolicyMock.Setup(x => x.Execute(It.IsAny <Action>())).Callback <Action>(a => a.Invoke());
connectionWrapper.Open();
retryPolicyMock.Verify(x => x.Execute(It.IsAny <Action>()));
dbConnectionMock.Verify(x => x.Open());
}
public void ShouldBeginTransactionInInnerConnectionAnReturnWrapper()
{
var testIsolationLevel = IsolationLevel.ReadCommitted;
var dbConnectionMock = new MockDbConnection();
Mock <ISyncPolicy> retryPolicyMock = new Mock <ISyncPolicy>();
var connectionWrapper = new ReliableDbConnectionWrapper(dbConnectionMock, retryPolicyMock.Object);
var obtainedTransaction = connectionWrapper.BeginTransaction(testIsolationLevel);
Assert.Equal(1, ((MockDbConnection)connectionWrapper.InnerConnection).BeginDbTransactionCount);
Assert.Equal(testIsolationLevel, ((MockDbConnection)dbConnectionMock).LastUsedTransactionIsolationLevel);
Assert.True(obtainedTransaction is ReliableDbTransactionWrapper);
Assert.True(((ReliableDbTransactionWrapper)obtainedTransaction).InnerTransaction is MockDbTransaction);
}
public void ShouldTakeIsolationLevelFromInnerTransaction()
{
IsolationLevel testIsolationLevel = IsolationLevel.ReadCommitted;
Mock <DbConnection> dbConnectionMock = new Mock <DbConnection>();
Mock <DbTransaction> dbTransactionMock = new Mock <DbTransaction>();
Mock <ISyncPolicy> retryPolicyMock = new Mock <ISyncPolicy>();
ReliableDbConnectionWrapper connectionWrapper = new ReliableDbConnectionWrapper(dbConnectionMock.Object, retryPolicyMock.Object);
dbTransactionMock.Setup(x => x.IsolationLevel).Returns(testIsolationLevel);
var transactionWrapper = new ReliableDbTransactionWrapper(dbTransactionMock.Object, connectionWrapper, retryPolicyMock.Object);
Assert.Equal(testIsolationLevel, transactionWrapper.IsolationLevel);
}
public void ShouldRollBackWithRetriesInInnerTransaction()
{
Mock <DbConnection> dbConnectionMock = new Mock <DbConnection>();
Mock <DbTransaction> dbTransactionMock = new Mock <DbTransaction>();
Mock <ISyncPolicy> retryPolicyMock = new Mock <ISyncPolicy>();
ReliableDbConnectionWrapper connectionWrapper = new ReliableDbConnectionWrapper(dbConnectionMock.Object, retryPolicyMock.Object);
var transactionWrapper = new ReliableDbTransactionWrapper(dbTransactionMock.Object, connectionWrapper, retryPolicyMock.Object);
retryPolicyMock.Setup(x => x.Execute(It.IsAny <Action>())).Callback <Action>(a => a.Invoke());
transactionWrapper.Rollback();
retryPolicyMock.Verify(x => x.Execute(It.IsAny <Action>()));
dbTransactionMock.Verify(x => x.Rollback());
}
