public void TestBindByNameWithWrappedConnection() { var wrapped = new ReliableConnection((DbConnection)_connection); // if the sql uses the same name twice, we need to set bindbyname to true var sql = @"select :p1 p1, :p1 p1, :p2 p2 from dual"; var args = new { p1 = "one", p2 = "two" }; var result = wrapped.QuerySql<dynamic>(sql, args); result = wrapped.QuerySql<dynamic>(sql, args); }
public void TestReliableConnection() { int retries = 0; var retryStrategy = new RetryStrategy(); retryStrategy.MaxRetryCount = 1; retryStrategy.Retrying += (sender, re) => { Console.WriteLine("Retrying. Attempt {0}", re.Attempt); retries++; }; try { var builder = new OracleConnectionStringBuilder(_connectionStringBuilder.ConnectionString); builder.DataSource = "testserver:9999"; using (var reliable = new ReliableConnection<OracleConnection>(builder.ConnectionString, retryStrategy)) { reliable.Open(); } } catch { } Assert.AreEqual(1, retries); }
public void CanCallWrappedConnectionMultiThreaded() { var reliable = new ReliableConnection((DbConnection)Connection()); var foo = reliable.AsParallel<IMultiThreaded>(); var tasks = new List<Task>(); for (int i = 0; i < 100; i++) tasks.Add(foo.FooAsync(i)); Task.WaitAll(tasks.ToArray()); }
/// <summary> /// Initializes a new instance of the ReliableCommand class, and bind it to the specified ReliableConnection and innerCommand. /// </summary> /// <param name="retryStrategy">The retry strategy to use for the command.</param> /// <param name="innerConnection">The innerConnection to bind to.</param> /// <param name="innerCommand">The innerCommand to bind to.</param> public ReliableCommand(IRetryStrategy retryStrategy, ReliableConnection innerConnection, DbCommand innerCommand) : base(innerConnection, innerCommand) { _retryStrategy = retryStrategy; }
public void ExecuteStoredProcWithTVPThroughReliableConnection() { using (ReliableConnection retry = new ReliableConnection<SqlConnection>(ConnectionString, RetryStrategy)) { retry.Open(); // the ListParameterHelper.AddEnumerableClassParameters code looks specifically for SqlCommand. // This test ensures that reliable connections work with this. var result = retry.Query<int>("ReflectInt32Table", new int[] { 1, 2, 3, 4, 5 }); Assert.AreEqual(5, result.Count()); } }
public void NonTransientExceptionDoesNotRetry() { // all exceptions are bad _mockRetryStrategy.Setup(r => r.IsTransientException(It.IsAny<Exception>())).Returns(false); // try a bad connection SqlConnectionStringBuilder b = new SqlConnectionStringBuilder(_connection.ConnectionString); b.InitialCatalog = "bad"; ReliableConnection<SqlConnection> retry = new ReliableConnection<SqlConnection>(b.ConnectionString, RetryStrategy); try { retry.Query("SELECT 1"); } catch { } Assert.IsFalse(Retries > 0); }
public void AsyncWorksWithReliableConnection() { // try a bad connection SqlConnectionStringBuilder b = new SqlConnectionStringBuilder(_connection.ConnectionString); ReliableConnection<SqlConnection> retry = new ReliableConnection<SqlConnection>(b.ConnectionString, RetryStrategy); int result = retry.QuerySqlAsync<int>("SELECT 10").Result.First(); Assert.AreEqual(10, result); }
public void TestReliableConnection() { int retries = 0; var retryStrategy = new RetryStrategy(); retryStrategy.MaxRetryCount = 1; retryStrategy.Retrying += (sender, re) => { Console.WriteLine("Retrying. Attempt {0}", re.Attempt); retries++; }; try { DB2ConnectionStringBuilder connectionStringBuilder = new DB2ConnectionStringBuilder(); connectionStringBuilder.ConnectionString = "Server=testserver:9999;Database=SAMPLE"; connectionStringBuilder.UserID = "db2admin"; connectionStringBuilder.Password = "******"; using (var reliable = new ReliableConnection<DB2Connection>(connectionStringBuilder.ConnectionString, retryStrategy)) { reliable.Open(); } } catch { } Assert.AreEqual(1, retries); }
public void AsyncBadOpenPerformsRetry() { // try a bad connection SqlConnectionStringBuilder b = new SqlConnectionStringBuilder(_connection.ConnectionString); b.InitialCatalog = "bad"; ReliableConnection<SqlConnection> retry = new ReliableConnection<SqlConnection>(b.ConnectionString, RetryStrategy); RetryStrategy.MaxRetryCount = 5; try { retry.QueryAsync("SELECT 1").Wait(); } catch { } Assert.AreEqual(5, Retries); }
public void AsyncBadQueryPerformsRetry() { // try a bad connection SqlConnectionStringBuilder b = new SqlConnectionStringBuilder(_connection.ConnectionString); ReliableConnection<SqlConnection> retry = new ReliableConnection<SqlConnection>(b.ConnectionString, RetryStrategy); RetryStrategy.MaxRetryCount = 5; try { retry.QuerySqlAsync("INVALID SQL").Wait(); } catch { } Assert.AreEqual(5, Retries); }
public void StoredProcedureParametersDetectedWithReliableSqlConnection() { ReliableConnection retry = new ReliableConnection(_connection, RetryStrategy); // the SqlCommand.DeriveParameters code looks specifically for SqlCommand. // This test ensures that reliable connections work with this. using (IDbTransaction t = retry.BeginTransaction()) { retry.ExecuteSql("CREATE PROC InsightTestProc (@Value int = 5) AS SELECT Value=@Value", transaction: t); int result = retry.Query<int>("InsightTestProc", new { Value = 1 }, transaction: t).First(); Assert.AreEqual(1, result); } }
public void ExecuteStoredProcWithTVPThroughReliableConnection() { ReliableConnection retry = new ReliableConnection(_connection, RetryStrategy); try { retry.ExecuteSql("CREATE TYPE [Int32Table] AS TABLE ([Value] [int])"); retry.ExecuteSql("CREATE PROC InsightTestProc (@Value Int32Table READONLY) AS SELECT * FROM @Value"); // the ListParameterHelper.AddEnumerableClassParameters code looks specifically for SqlCommand. // This test ensures that reliable connections work with this. var result = retry.Query<int>("InsightTestProc", new int[] { 1, 2, 3, 4, 5 }); Assert.AreEqual(5, result.Count()); } finally { Cleanup("IF EXISTS (SELECT * FROM sys.objects WHERE name = 'InsightTestProc') DROP PROCEDURE [InsightTestProc]"); Cleanup("IF EXISTS (SELECT * FROM sys.types WHERE name = 'Int32Table') DROP TYPE [Int32Table]"); } }
public void MaxRetryCountCapsNumberOfRetries() { int retries = 0; RetryStrategy.Retrying += (sender, re) => { retries++; }; RetryStrategy.MaxRetryCount = 5; // try a bad connection SqlConnectionStringBuilder b = new SqlConnectionStringBuilder(_connection.ConnectionString); b.InitialCatalog = "bad"; ReliableConnection<SqlConnection> retry = new ReliableConnection<SqlConnection>(b.ConnectionString, RetryStrategy); try { retry.Query("SELECT 1"); } catch { } Assert.AreEqual(5, retries); }
public void BadOpenPerformsRetry() { // try a bad connection SqlConnectionStringBuilder b = new SqlConnectionStringBuilder(_connection.ConnectionString); b.InitialCatalog = "bad"; ReliableConnection<SqlConnection> retry = new ReliableConnection<SqlConnection>(b.ConnectionString, RetryStrategy); try { retry.Query("SELECT 1"); } catch { } Assert.IsTrue(Retries > 0); }
public void ReliableShouldWorkWithTransaction() { var reliable = new ReliableConnection((DbConnection)Connection()); using (var conn = reliable.OpenWithTransaction()) { var ret = conn.QuerySql(@"SELECT 1"); } }
public void TestReliableConnection() { int retries = 0; var retryStrategy = new RetryStrategy(); retryStrategy.MaxRetryCount = 1; retryStrategy.Retrying += (sender, re) => { Console.WriteLine("Retrying. Attempt {0}", re.Attempt); retries++; }; try { var builder = new MySqlConnectionStringBuilder(_connectionStringBuilder.ConnectionString); builder.Server = "localhost"; builder.Port = 9999; using (var reliable = new ReliableConnection<MySqlConnection>(builder.ConnectionString, retryStrategy)) { reliable.Open(); } } catch { } Assert.AreEqual(1, retries); }
public void TestReliableConnection() { int retries = 0; var retryStrategy = new RetryStrategy(); retryStrategy.MaxRetryCount = 1; retryStrategy.Retrying += (sender, re) => { Console.WriteLine("Retrying. Attempt {0}", re.Attempt); retries++; }; try { var builder = new AseConnectionStringBuilder(); builder.ConnectionString = "Data Source=testserver;Port=9999;User ID=sa;Password=Password1"; using (var reliable = new ReliableConnection<AseConnection>(builder.ConnectionString, retryStrategy)) { reliable.Open(); } } catch { } Assert.AreEqual(1, retries); }