public Spec AnyCachedRequestThatHasNotGotAResponseInTheCacheHandledBeforeTheFirstExceptionCallsTheHandleMethod(IList<Tuple<Request, DescribedAction>> input, Response[] output)
        {
            return new Spec(
                () =>
                {
                    var nonFailedRequests =
                        input
                            .Select(tuple => tuple.First)
                            .Take(GetIndexOfFirstExceptionThrown() + 1)
                            .Where(request => request.GetType().HasAttribute<EnableServiceResponseCachingAttribute>());

                    var requestTypes =
                        nonFailedRequests
                            .Select(request => request.GetType())
                            .Distinct();

                    var requestsThatReturnedACachedResponse =
                        nonFailedRequests
                            .Where(request => State.CacheManager.ReturnedCachedResponseFor(request));

                    requestTypes.ForEach(
                        type =>
                        Ensure.Equal(
                            nonFailedRequests.Count(request => request.GetType() == type)
                            - requestsThatReturnedACachedResponse.Count(request => request.GetType() == type),
                            State.GetHandler(type).HandledRequest));
                })
                .IfAfter(ExceptionWasThrownAfterTheFirstRequest);
        }
 protected override void When()
 {
     using (var requestProcessor = IoC.Container.Resolve<IRequestProcessor>())
     {
         response = requestProcessor.Process(request).SingleOrDefault();
     }
 }
        public Type GetRequestTypeFor(Response response)
        {
            if (response == null) throw new ArgumentNullException("response");
            var responseType = response.GetType();
            if (!responseRequestMappings.ContainsKey(responseType))
                throw new Exception("No request type found by convention for response type " + responseType);

            return responseRequestMappings[responseType];
        }
Esempio n. 4
0
        /// <summary>
        /// Called when [process requests completed].
        /// </summary>
        /// <param name="processRequestsAsyncCompletedArgs">The process requests async completed args.</param>
        /// <param name="responseReciever">The response reciever.</param>
        /// <param name="tempResponseArray">The temp response array.</param>
        /// <param name="requestsToSendAsArray">The requests to send as array.</param>
        public override void OnProcessRequestsCompleted(
            ProcessRequestsAsyncCompletedArgs processRequestsAsyncCompletedArgs,
            ResponseReceiver responseReciever,
            Response[] tempResponseArray,
            Request[] requestsToSendAsArray )
        {
            base.OnProcessRequestsCompleted ( processRequestsAsyncCompletedArgs, responseReciever, tempResponseArray, requestsToSendAsArray );

            var requestEndTime = DateTime.Now;
            var timespan = requestEndTime - _requestStartTime;
            var requestString = GetRequestString ( requestsToSendAsArray );

            Logger.Debug (
                "Response received for the following agatha batch: [{0}].  Elapsed milliseconds ({1})", requestString, timespan.TotalMilliseconds );
        }
        public Spec AnyNonCachedRequestHandledAfterAndIncludingTheFirstExceptionCallsTheCreateDefaultResponseMethod(IList<Tuple<Request, DescribedAction>> input, Response[] output)
        {
            return new Spec(
                () =>
                    {
                        var requestsAfterTheFirstException =
                            input
                                .Select(tuple => tuple.First)
                                .Skip(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),
                                State.GetHandler(type).DefaultResponseReturned));
                    })
                .IfAfter(ExceptionWasThrownBeforeLastRequest);
        }
        private void SetExceptionType(Response response, Exception exception)
        {
            var exceptionType = exception.GetType();

            if (exceptionType.Equals(serviceLayerConfiguration.BusinessExceptionType))
            {
                response.ExceptionType = ExceptionType.Business;
                SetExceptionFaultCode(exception, response.Exception);

                return;
            }

            if (exceptionType.Equals(serviceLayerConfiguration.SecurityExceptionType))
            {
                response.ExceptionType = ExceptionType.Security;
                SetExceptionFaultCode(exception, response.Exception);
                return;
            }

            response.ExceptionType = ExceptionType.Unknown;
        }
Esempio n. 7
0
 protected Request GetRequestFor(Response response)
 {
     return input.Select(i => i.Item1).ElementAt(output.ToList().IndexOf(response));
 }
Esempio n. 8
0
 private Response SetStandardExceptionInfoWhenEarlierRequestsFailed(Response response)
 {
     response.ExceptionType = ExceptionType.EarlierRequestAlreadyFailed;
     response.Exception = new ExceptionInfo(new Exception(ExceptionType.EarlierRequestAlreadyFailed.ToString()));
     return response;
 }
Esempio n. 9
0
 protected virtual void AfterHandle(Request request, Response response)
 {
 }
Esempio n. 10
0
 public void MarkAsProcessed(Response response)
 {
     if (response == null) throw new ArgumentNullException("response");
     Response = response;
     IsProcessed = true;
 }
Esempio n. 11
0
 /// <summary>
 /// Stores the specified request.
 /// </summary>
 /// <param name="request">The request.</param>
 /// <param name="response">The response.</param>
 /// <param name="expiration">The expiration.</param>
 public void Store(Request request, Response response, TimeSpan expiration)
 {
     Cache.Put(BuildKey(request), response, expiration);
 }
Esempio n. 12
0
 public CacheEntry(Request request, Response response, TimeSpan expiration, string region)
 {
     Request = request;
     Response = response;
     Expiration = expiration;
     Region = region;
 }
Esempio n. 13
0
 protected override void StoreInCache(Request request, Response response, TimeSpan expiration, string region)
 {
     cacheEntries.Add(new CacheEntry(request, response, expiration, region));
     base.StoreInCache(request, response, expiration, region);
 }
 public Spec CachableRequestsNeverCallTheCreateDefaultResponseMethodImplicitely(IList<Tuple<Request, DescribedAction>> input, Response[] output)
 {
     return new Spec(
         () => input
                   .Where(request => request.GetType().HasAttribute<EnableServiceResponseCachingAttribute>())
                   .Select(request => request.GetType())
                   .Distinct()
                   .ForEach(type => Ensure.Equal(0, State.GetHandler(type).DefaultResponseReturned)));
 }
 public override void StoreInCache(Request request, Response response)
 {
     if (((RequestBase)request).BypassCache)
         return;
     base.StoreInCache(request, response);
 }