public void SendAsync_ThrowException_WithoutExceptionHandler()
{
var handler = new ExceptionMessageHandler {
ThrowException = true
};
var configurableHanlder = new ConfigurableMessageHandler(handler);
using (var client = new HttpClient(configurableHanlder))
{
var request = new HttpRequestMessage(HttpMethod.Get, "https://test-exception-handler");
try
{
HttpResponseMessage response = client.SendAsync(request).Result;
Assert.Fail("SendAsync should throw an exception");
}
catch (AggregateException ae)
{
Assert.That(ae.InnerException.Message, Is.EqualTo(ExceptionMessageHandler.ExceptionMessage));
}
catch (Exception)
{
Assert.Fail("AggregateException was suppose to be thrown");
}
Assert.That(handler.Calls, Is.EqualTo(1));
}
}
/// <summary>Subtest that back-off handler works as expected when exception is or isn't thrown.</summary>
private void SubtestSendAsync_BackOffExceptionHandler(bool throwException,
BackOffHandler.Initializer initializer, Exception exceptionToThrow = null)
{
var handler = new ExceptionMessageHandler {
ThrowException = throwException
};
if (exceptionToThrow != null)
{
handler.Exception = exceptionToThrow;
}
var configurableHanlder = new ConfigurableMessageHandler(handler);
var boHandler = new MockBackOffHandler(initializer);
configurableHanlder.AddExceptionHandler(boHandler);
int boHandleCount = 0;
// if an exception should be thrown and the handler can handle it then calculate the handle count by the
// lg(MaxTimeSpan)
if (throwException && initializer.HandleExceptionFunc(exceptionToThrow))
{
boHandleCount = Math.Min((int)Math.Floor(Math.Log(boHandler.MaxTimeSpan.TotalSeconds, 2)) + 1,
configurableHanlder.NumTries - 1);
boHandleCount = boHandleCount >= 0 ? boHandleCount : 0;
}
using (var client = new HttpClient(configurableHanlder))
{
var request = new HttpRequestMessage(HttpMethod.Get, "https://test-exception-handler");
try
{
HttpResponseMessage response = client.SendAsync(request).Result;
Assert.False(throwException);
}
catch (AggregateException ae)
{
Assert.True(throwException);
// Don't compare exception messages because for TaskCanceledException the message
// on Mono is different if there is a task associated with the exception.
Assert.AreEqual(handler.Exception.GetType(), ae.InnerException.GetType());
}
Assert.That(boHandler.Waits.Count, Is.EqualTo(boHandleCount));
// check the exponential behavior - wait 1, 2, 4, 8, ... seconds.
if (throwException)
{
for (int i = 0; i < boHandler.Waits.Count; ++i)
{
Assert.That(boHandler.Waits[i].TotalSeconds, Is.EqualTo((int)Math.Pow(2, i)));
}
}
Assert.That(handler.Calls, Is.EqualTo(boHandleCount + 1));
}
}
/// <summary> Subtest for exception handler which tests that exception handler is invoked. </summary>
private void SubtestSendAsyncExceptionHandler(bool throwException, bool handle)
{
var handler = new ExceptionMessageHandler {
ThrowException = throwException
};
var configurableHanlder = new ConfigurableMessageHandler(handler);
var exceptionHandler = new ExceptionMessageHandler.ExceptionHandler {
Handle = handle
};
configurableHanlder.ExceptionHandlers.Add(exceptionHandler);
using (var client = new HttpClient(configurableHanlder))
{
var request = new HttpRequestMessage(HttpMethod.Get, "https://test-exception-handler");
try
{
HttpResponseMessage response = client.SendAsync(request).Result;
if (throwException)
{
Assert.Fail("SendAsync should throw an exception");
}
}
catch (AggregateException ae)
{
Assert.That(ae.InnerException.Message, Is.EqualTo(ExceptionMessageHandler.ExceptionMessage));
}
// if exception is thrown, check if it's handles. if so, there should be num tries calls, otherwise
// only 1
if (throwException)
{
Assert.That(exceptionHandler.Calls, Is.EqualTo(handle ? configurableHanlder.NumTries : 1));
}
// exception wasn't supposed to be thrown, so no call to exception handler should be made
else
{
Assert.That(exceptionHandler.Calls, Is.EqualTo(0));
}
Assert.That(handler.Calls, Is.EqualTo(throwException & handle ? configurableHanlder.NumTries : 1));
}
}
public void WriteLine(Exception exception)
{
if (_mainForm == null)
{
return;
}
if (_mainForm.InvokeRequired)
{
ExceptionMessageHandler handler = new ExceptionMessageHandler(
_mainForm.ProgressException);
_mainForm.Invoke(handler, new object[] { exception });
}
else
{
_mainForm.ProgressException(exception);
}
}
/// <summary>Subtest that back-off handler works as expected when exception is or isn't thrown.</summary>
private void SubtestSendAsync_BackOffExceptionHandler(bool throwException,
BackOffHandler.Initializer initializer, Exception exceptionToThrow = null)
{
var handler = new ExceptionMessageHandler { ThrowException = throwException };
if (exceptionToThrow != null)
{
handler.Exception = exceptionToThrow;
}
var configurableHanlder = new ConfigurableMessageHandler(handler);
var boHandler = new MockBackOffHandler(initializer);
configurableHanlder.AddExceptionHandler(boHandler);
int boHandleCount = 0;
// if an exception should be thrown and the handler can handle it then calculate the handle count by the
// lg(MaxTimeSpan)
if (throwException && initializer.HandleExceptionFunc(exceptionToThrow))
{
boHandleCount = Math.Min((int)Math.Floor(Math.Log(boHandler.MaxTimeSpan.TotalSeconds, 2)) + 1,
configurableHanlder.NumTries - 1);
boHandleCount = boHandleCount >= 0 ? boHandleCount : 0;
}
using (var client = new HttpClient(configurableHanlder))
{
var request = new HttpRequestMessage(HttpMethod.Get, "https://test-exception-handler");
try
{
HttpResponseMessage response = client.SendAsync(request).Result;
Assert.False(throwException);
}
catch (AggregateException ae)
{
Assert.True(throwException);
// Don't compare exception messages because for TaskCanceledException the message
// on Mono is different if there is a task associated with the exception.
Assert.AreEqual(handler.Exception.GetType(), ae.InnerException.GetType());
}
Assert.That(boHandler.Waits.Count, Is.EqualTo(boHandleCount));
// check the exponential behavior - wait 1, 2, 4, 8, ... seconds.
if (throwException)
{
for (int i = 0; i < boHandler.Waits.Count; ++i)
{
Assert.That(boHandler.Waits[i].TotalSeconds, Is.EqualTo((int)Math.Pow(2, i)));
}
}
Assert.That(handler.Calls, Is.EqualTo(boHandleCount + 1));
}
}
public void SendAsync_ThrowException_WithoutExceptionHandler()
{
var handler = new ExceptionMessageHandler { ThrowException = true };
var configurableHanlder = new ConfigurableMessageHandler(handler);
using (var client = new HttpClient(configurableHanlder))
{
var request = new HttpRequestMessage(HttpMethod.Get, "https://test-exception-handler");
try
{
HttpResponseMessage response = client.SendAsync(request).Result;
Assert.Fail("SendAsync should throw an exception");
}
catch (AggregateException ae)
{
Assert.That(ae.InnerException.Message, Is.EqualTo(ExceptionMessageHandler.ExceptionMessage));
}
catch (Exception)
{
Assert.Fail("AggregateException was suppose to be thrown");
}
Assert.That(handler.Calls, Is.EqualTo(1));
}
}
/// <summary>Subtest for exception handler which tests that exception handler is invoked.</summary>
private void SubtestSendAsyncExceptionHandler(bool throwException, bool handle)
{
var handler = new ExceptionMessageHandler { ThrowException = throwException };
var configurableHanlder = new ConfigurableMessageHandler(handler);
var exceptionHandler = new ExceptionMessageHandler.ExceptionHandler { Handle = handle };
configurableHanlder.AddExceptionHandler(exceptionHandler);
using (var client = new HttpClient(configurableHanlder))
{
var request = new HttpRequestMessage(HttpMethod.Get, "https://test-exception-handler");
try
{
HttpResponseMessage response = client.SendAsync(request).Result;
if (throwException)
{
Assert.Fail("SendAsync should throw an exception");
}
}
catch (AggregateException ae)
{
Assert.That(ae.InnerException.Message, Is.EqualTo(ExceptionMessageHandler.ExceptionMessage));
}
// if exception is thrown, check if it's handles. if so, there should be num tries calls, otherwise
// only 1
if (throwException)
{
Assert.That(exceptionHandler.Calls, Is.EqualTo(handle ? configurableHanlder.NumTries : 1));
}
// exception wasn't supposed to be thrown, so no call to exception handler should be made
else
{
Assert.That(exceptionHandler.Calls, Is.EqualTo(0));
}
Assert.That(handler.Calls, Is.EqualTo(throwException & handle ? configurableHanlder.NumTries : 1));
}
}
