public void SetUp()
{
options = new Options {
Timeout = TimeSpan.FromMilliseconds(200), RetryInterval = TimeSpan.FromMilliseconds(10)
};
retryUntilTimeoutRobustWrapper = new RetryUntilTimeoutRobustWrapper();
}
private void When_a_Function_always_throws_an_exception_It_retries_until_the_timeout_is_reached(int timeoutMilliseconds, int intervalMilliseconds)
{
var expectedTimeout = TimeSpan.FromMilliseconds(timeoutMilliseconds);
Configuration.Timeout = expectedTimeout;
Configuration.RetryInterval = TimeSpan.FromMilliseconds(intervalMilliseconds);
Stopwatch stopWatch = null;
long lastCall = 0;
Func <object> alwaysThrows = () =>
{
lastCall = stopWatch.ElapsedMilliseconds;
throw new ExplicitlyThrownTestException("Function fails every time");
};
var retryUntilTimeoutRobustWrapper = new RetryUntilTimeoutRobustWrapper();
try {
stopWatch = Stopwatch.StartNew();
retryUntilTimeoutRobustWrapper.Robustly(alwaysThrows);
}
catch (ExplicitlyThrownTestException) { stopWatch.Stop(); }
Assert.That(lastCall, Is.InRange(expectedTimeout.TotalMilliseconds - (Configuration.RetryInterval.Milliseconds + When_waiting.AccuracyMilliseconds),
expectedTimeout.TotalMilliseconds + Configuration.RetryInterval.Milliseconds + When_waiting.AccuracyMilliseconds));
}
public void When_a_query_succeeds_first_time_It_only_tries_once()
{
var expectedResult = new object();
var alwaysSucceedsQuery = new AlwaysSucceedsQuery <object>(expectedResult, TimeSpan.Zero, TimeSpan.Zero);
var actualResult = new RetryUntilTimeoutRobustWrapper().Robustly(alwaysSucceedsQuery);
Assert.That(alwaysSucceedsQuery.Tries, Is.EqualTo(1));
Assert.That(actualResult, Is.SameAs(expectedResult));
}
public void When_a_query_succeeds_first_time_It_only_tries_once()
{
var expectedResult = new object();
var alwaysSucceedsQuery = new AlwaysSucceedsQuery<object>(expectedResult,TimeSpan.Zero,TimeSpan.Zero);
var actualResult = new RetryUntilTimeoutRobustWrapper().Robustly(alwaysSucceedsQuery);
Assert.That(alwaysSucceedsQuery.Tries, Is.EqualTo(1));
Assert.That(actualResult, Is.SameAs(expectedResult));
}
public void When_a_query_throws_an_exception_first_time_It_retries()
{
var expectedResult = new object();
var query = new ThrowsSecondTimeQuery <object>(expectedResult, TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(10));
var actualReturnValue = new RetryUntilTimeoutRobustWrapper().Robustly(query);
Assert.That(query.Tries, Is.EqualTo(2));
Assert.That(actualReturnValue, Is.SameAs(expectedResult));
}
public void When_an_action_throws_a_not_supported_exception_It_does_not_retry()
{
var retryInterval = TimeSpan.FromMilliseconds(10);
var robustness = new RetryUntilTimeoutRobustWrapper();
var query = new AlwaysThrowsQuery<object, NotSupportedException>(TimeSpan.FromMilliseconds(100), retryInterval);
Assert.Throws<NotSupportedException>(() => robustness.Robustly(query));
Assert.That(query.Tries, Is.EqualTo(1));
}
public void When_a_query_throws_a_not_supported_exception_It_does_not_retry()
{
var retryInterval = TimeSpan.FromMilliseconds(10);
var robustness = new RetryUntilTimeoutRobustWrapper();
var query = new AlwaysThrowsQuery <object, NotSupportedException>(TimeSpan.FromMilliseconds(100), retryInterval);
Assert.Throws <NotSupportedException>(() => robustness.Robustly(query));
Assert.That(query.Tries, Is.EqualTo(1));
}
public void When_an_Action_throws_a_not_supported_exception_It_retries()
{
Configuration.Timeout = TimeSpan.FromMilliseconds(100);
var robustness = new RetryUntilTimeoutRobustWrapper();
var tries = 0;
Action action = () =>
{
tries++;
throw new NotSupportedException("Fails first time");
};
Assert.Throws <NotSupportedException>(() => robustness.Robustly(action));
Assert.That(tries, Is.EqualTo(1));
}
public void When_an_Action_throws_a_not_supported_exception_It_retries()
{
Configuration.Timeout = TimeSpan.FromMilliseconds(100);
var robustness = new RetryUntilTimeoutRobustWrapper();
var tries = 0;
Action action = () =>
{
tries++;
throw new NotSupportedException("Fails first time");
};
Assert.Throws<NotSupportedException>(() => robustness.Robustly(action));
Assert.That(tries, Is.EqualTo(1));
}
public void When_a_Function_succeeds_first_time_It_only_tries_once()
{
var retries = 0;
var expectedReturnValue = new object();
Func <object> alwaysSucceeds = () =>
{
retries++;
return(expectedReturnValue);
};
var actualResult = new RetryUntilTimeoutRobustWrapper().Robustly(alwaysSucceeds);
Assert.That(retries, Is.EqualTo(1));
Assert.That(actualResult, Is.SameAs(expectedReturnValue));
}
public void When_an_Action_throws_an_exception_first_time_It_retries()
{
Configuration.Timeout = TimeSpan.FromMilliseconds(100);
var robustness = new RetryUntilTimeoutRobustWrapper();
var tries = 0;
Action action = () =>
{
tries++;
if (tries == 1)
throw new ExplicitlyThrownTestException("Fails first time");
};
robustness.Robustly(action);
Assert.That(tries, Is.EqualTo(2));
}
private void When_a_query_always_throws_an_exception_It_retries_until_the_timeout_is_reached(int timeoutMilliseconds, int intervalMilliseconds)
{
var expectedTimeout = TimeSpan.FromMilliseconds(timeoutMilliseconds);
var retryInterval = TimeSpan.FromMilliseconds(intervalMilliseconds);
var query = new AlwaysThrowsQuery <object, TestException>(expectedTimeout, retryInterval);
var retryUntilTimeoutRobustWrapper = new RetryUntilTimeoutRobustWrapper();
try
{
retryUntilTimeoutRobustWrapper.Robustly(query);
Assert.Fail("Expecting test exception");
}
catch (TestException) {}
Assert.That(query.LastCall, Is.InRange(expectedTimeout.TotalMilliseconds - (retryInterval.Milliseconds + When_waiting.AccuracyMilliseconds),
expectedTimeout.TotalMilliseconds + retryInterval.Milliseconds + When_waiting.AccuracyMilliseconds));
}
public void When_a_Function_throws_an_exception_first_time_It_retries()
{
Configuration.Timeout = TimeSpan.FromMilliseconds(100);
Configuration.RetryInterval = TimeSpan.FromMilliseconds(10);
var robustness = new RetryUntilTimeoutRobustWrapper();
var tries = 0;
var expectedReturnValue = new object();
Func<object> function = () =>
{
tries++;
if (tries == 1)
throw new Exception("Fails first time");
return expectedReturnValue;
};
var actualReturnValue = robustness.Robustly(function);
Assert.That(tries, Is.EqualTo(2));
Assert.That(actualReturnValue, Is.SameAs(expectedReturnValue));
}
public void When_a_Function_throws_an_exception_first_time_It_retries()
{
Configuration.Timeout = TimeSpan.FromMilliseconds(100);
Configuration.RetryInterval = TimeSpan.FromMilliseconds(10);
var tries = 0;
var expectedReturnValue = new object();
Func <object> throwsOnce = () =>
{
tries++;
if (tries == 1)
{
throw new Exception("Fails first time");
}
return(expectedReturnValue);
};
var actualReturnValue = new RetryUntilTimeoutRobustWrapper().Robustly(throwsOnce);
Assert.That(tries, Is.EqualTo(2));
Assert.That(actualReturnValue, Is.SameAs(expectedReturnValue));
}
public void When_an_Action_throws_a_recurring_exception_It_retries_until_the_timeout_is_reached_then_rethrows()
{
var timeout = TimeSpan.FromMilliseconds(200);
Configuration.Timeout = timeout;
Configuration.RetryInterval = TimeSpan.FromMilliseconds(10);
var robustness = new RetryUntilTimeoutRobustWrapper();
Action action = () => { throw new ExplicitlyThrownTestException("Fails every time"); };
var startTime = DateTime.Now;
try
{
robustness.Robustly(action);
Assert.Fail("Expected 'Fails every time' exception");
}
catch (ExplicitlyThrownTestException e)
{
Assert.That(e.Message, Is.EqualTo("Fails every time"));
}
var endTime = DateTime.Now;
var actualDuration = (endTime - startTime);
var discrepancy = TimeSpan.FromMilliseconds(50);
Assert.That(actualDuration, Is.LessThan(timeout + discrepancy));
}
public void SetUp()
{
retryInterval = TimeSpan.FromMilliseconds(10);
retryUntilTimeoutRobustWrapper = new RetryUntilTimeoutRobustWrapper();
}
public void SetUp()
{
options = new Options {Timeout = TimeSpan.FromMilliseconds(200), RetryInterval = TimeSpan.FromMilliseconds(10)};
retryUntilTimeoutRobustWrapper = new RetryUntilTimeoutRobustWrapper();
}
public void When_a_Function_throws_a_recurring_exception_It_retries_until_the_timeout_is_reached_then_rethrow()
{
var expectedTimeout = TimeSpan.FromMilliseconds(200);
Configuration.RetryInterval = TimeSpan.FromMilliseconds(10);
Configuration.Timeout = expectedTimeout;
var robustness = new RetryUntilTimeoutRobustWrapper();
Func<object> function = () => { throw new ExplicitlyThrownTestException("Fails every time"); };
var startTime = DateTime.Now;
try
{
robustness.Robustly(function);
Assert.Fail("Expected 'Fails every time' exception");
}
catch (ExplicitlyThrownTestException e)
{
Assert.That(e.Message, Is.EqualTo("Fails every time"));
}
var endTime = DateTime.Now;
var actualDuration = (endTime - startTime);
var tollerance = TimeSpan.FromMilliseconds(50);
Assert.That(actualDuration, Is.InRange(expectedTimeout, expectedTimeout + tollerance));
}
public void SetUp()
{
Configuration.Timeout = TimeSpan.FromMilliseconds(200);
Configuration.RetryInterval = TimeSpan.FromMilliseconds(10);
retryUntilTimeoutRobustWrapper = new RetryUntilTimeoutRobustWrapper();
}
private void When_a_Function_always_throws_an_exception_It_retries_until_the_timeout_is_reached(int timeoutMilliseconds, int intervalMilliseconds)
{
var expectedTimeout = TimeSpan.FromMilliseconds(timeoutMilliseconds);
Configuration.Timeout = expectedTimeout;
Configuration.RetryInterval = TimeSpan.FromMilliseconds(intervalMilliseconds);
Stopwatch stopWatch = null;
long lastCall = 0;
Func<object> alwaysThrows = () =>
{
lastCall = stopWatch.ElapsedMilliseconds;
throw new ExplicitlyThrownTestException("Function fails every time");
};
var retryUntilTimeoutRobustWrapper = new RetryUntilTimeoutRobustWrapper();
try {
stopWatch = Stopwatch.StartNew();
retryUntilTimeoutRobustWrapper.Robustly(alwaysThrows);
}
catch (ExplicitlyThrownTestException) { stopWatch.Stop(); }
Assert.That(lastCall, Is.InRange(expectedTimeout.TotalMilliseconds - Configuration.RetryInterval.Milliseconds,
expectedTimeout.TotalMilliseconds + Configuration.RetryInterval.Milliseconds));
}
public void When_a_Function_succeeds_first_time_It_only_tries_once()
{
var retries = 0;
var expectedReturnValue = new object();
Func<object> alwaysSucceeds = () =>
{
retries++;
return expectedReturnValue;
};
var actualResult = new RetryUntilTimeoutRobustWrapper().Robustly(alwaysSucceeds);
Assert.That(retries, Is.EqualTo(1));
Assert.That(actualResult, Is.SameAs(expectedReturnValue));
}
public void SetUp()
{
retryInterval = TimeSpan.FromMilliseconds(10);
retryUntilTimeoutRobustWrapper = new RetryUntilTimeoutRobustWrapper();
}
private void When_a_query_always_throws_an_exception_It_retries_until_the_timeout_is_reached(int timeoutMilliseconds, int intervalMilliseconds)
{
var expectedTimeout = TimeSpan.FromMilliseconds(timeoutMilliseconds);
var retryInterval = TimeSpan.FromMilliseconds(intervalMilliseconds);
var query = new AlwaysThrowsQuery<object, TestException>(expectedTimeout, retryInterval);
var retryUntilTimeoutRobustWrapper = new RetryUntilTimeoutRobustWrapper();
try
{
retryUntilTimeoutRobustWrapper.Robustly(query);
Assert.Fail("Expecting test exception");
}
catch (TestException){}
Assert.That(query.LastCall, Is.InRange(expectedTimeout.TotalMilliseconds - (retryInterval.Milliseconds + When_waiting.AccuracyMilliseconds),
expectedTimeout.TotalMilliseconds + retryInterval.Milliseconds + When_waiting.AccuracyMilliseconds));
}
public void SetUp()
{
Configuration.Timeout = TimeSpan.FromMilliseconds(200);
Configuration.RetryInterval = TimeSpan.FromMilliseconds(10);
retryUntilTimeoutRobustWrapper = new RetryUntilTimeoutRobustWrapper();
}
public void When_a_query_throws_an_exception_first_time_It_retries()
{
var expectedResult = new object();
var query = new ThrowsSecondTimeQuery<object>(expectedResult, TimeSpan.FromMilliseconds(100),TimeSpan.FromMilliseconds(10));
var actualReturnValue = new RetryUntilTimeoutRobustWrapper().Robustly(query);
Assert.That(query.Tries, Is.EqualTo(2));
Assert.That(actualReturnValue, Is.SameAs(expectedResult));
}
