public Spec AnyCachedRequestThatHasNotGotAResponseInTheCacheHandledBeforeTheFirstExceptionCallsTheHandleMethod()
{
return(new Spec(
() =>
{
var nonFailedRequests =
input
.Select(tuple => tuple.Item1)
.Take(ProcessRequestsState.GetIndexOfFirstExceptionThrown() + 1)
.Where(request => request.GetType().HasAttribute <EnableServiceResponseCachingAttribute>());
var requestTypes =
nonFailedRequests
.Select(request => request.GetType())
.Distinct();
var requestsThatReturnedACachedResponse =
nonFailedRequests
.Where(request => ProcessRequestsState.CacheManager.ReturnedCachedResponseFor(request));
requestTypes.ForEach(
type =>
Ensure.Equal(
nonFailedRequests.Count(request => request.GetType() == type)
- requestsThatReturnedACachedResponse.Count(request => request.GetType() == type),
ProcessRequestsState.GetHandler(type).HandledRequest));
})
.IfAfter(ProcessRequestsState.ExceptionWasThrownAfterTheFirstRequest));
}
public Spec CachedResponsesDontCallTheHandler()
{
return(new Spec(
() =>
{
var requestTypes = input.Select(i => i.Item1.GetType()).Distinct().ToList();
foreach (var requestType in requestTypes)
{
var timesHandlerCalled = ProcessRequestsState.GetHandler(requestType).HandledRequest;
Type type = requestType;
var numberOfCachedResponsesReturned =
input
.Select(i => i.Item1)
.Where(request => request.GetType() == type)
.Where(request => ProcessRequestsState.CacheManager.ReturnedCachedResponseFor(request))
.Count();
var numberOfRequests =
input
.Select(i => i.Item1.GetType())
.Where(t => t == requestType)
.Count();
Ensure.Equal(numberOfRequests - numberOfCachedResponsesReturned, timesHandlerCalled);
}
})
.IfAfter(() => ProcessRequestsState.CacheManager.ReturnedCachedResponses.Any(r => r != null)));
}
public Spec CachableRequestsNeverCallTheCreateDefaultResponseMethodImplicitely()
{
return(new Spec(
() => input
.Where(request => request.GetType().HasAttribute <EnableServiceResponseCachingAttribute>())
.Select(request => request.GetType())
.Distinct()
.ForEach(type => Ensure.Equal(0, ProcessRequestsState.GetHandler(type).DefaultResponseReturned))));
}
private void EnsureExceptionInfoIsCorrect <TException>(ExceptionType exceptionTypeEnum, Response[] responses)
{
int index = ProcessRequestsState.GetIndexOfFirstExceptionThrown <TException>();
Ensure.Equal(exceptionTypeEnum, responses[index].ExceptionType);
Ensure.Equal(ProcessRequestsState.ExceptionsThrown[index].Message, responses[index].Exception.Message);
Ensure.Equal(ProcessRequestsState.ExceptionsThrown[index].StackTrace, responses[index].Exception.StackTrace);
Ensure.Equal(typeof(TException).FullName, responses[index].Exception.Type);
}
public Spec AnyNonCachedRequestHandledAfterAndIncludingTheFirstExceptionCallsTheCreateDefaultResponseMethod()
{
return(new Spec(
() =>
{
var requestsAfterTheFirstException =
input
.Select(tuple => tuple.Item1)
.Skip(ProcessRequestsState.GetIndexOfFirstExceptionThrown());
var requestTypes =
requestsAfterTheFirstException
.Select(request => request.GetType())
.Distinct()
.Where(type => !type.HasAttribute <EnableServiceResponseCachingAttribute>());
requestTypes.ForEach(
type =>
Ensure.Equal(
requestsAfterTheFirstException.Count(request => request.GetType() == type),
ProcessRequestsState.GetHandler(type).DefaultResponseReturned));
})
.IfAfter(ProcessRequestsState.ExceptionWasThrownBeforeLastRequest));
}
