public DefaultRequestDispatcherFixture() { this.responseProcessors = new List<IResponseProcessor>(); this.routeResolver = A.Fake<IRouteResolver>(); this.routeInvoker = A.Fake<IRouteInvoker>(); this.negotiator = A.Fake<IResponseNegotiator>(); A.CallTo(() => this.routeInvoker.Invoke(A<Route>._, A<CancellationToken>._, A<DynamicDictionary>._, A<NancyContext>._)) .ReturnsLazily(async arg => { var routeResult = ((Route)arg.Arguments[0]).Invoke((DynamicDictionary)arg.Arguments[2], new CancellationToken()).ConfigureAwait(false); var x = await routeResult; return (Response)x; }); this.requestDispatcher = new DefaultRequestDispatcher(this.routeResolver, this.responseProcessors, this.routeInvoker, this.negotiator); var resolvedRoute = new ResolveResult { Route = new FakeRoute(), Parameters = DynamicDictionary.Empty, Before = null, After = null, OnError = null }; A.CallTo(() => this.routeResolver.Resolve(A<NancyContext>._)).Returns(resolvedRoute); }
internal dynamic HandleInternalServerError(NancyContext context, Exception exception, IResponseNegotiator responseNegotiator, IHostingEnvironment env) { _logger.Error(exception, "Unhandled error on request: @{Url}. Error Message: @{Message}", context.Request.Url, exception.Message); var errorMessage = "There was an internal server error while processing the request."; errorMessage = env.IsDevelopment() ? $"{exception.Message} Stack Trace: {exception.StackTrace}" : errorMessage; context.NegotiationContext = new NegotiationContext(); var negotiator = new Negotiator(context) .WithStatusCode(HttpStatusCode.InternalServerError) .WithModel(new Error { Message = errorMessage, Code = ((int)HttpStatusCode.InternalServerError).ToString(), }) .WithHeaders(HttpResponseHeaders.CorsHeaders); var response = responseNegotiator.NegotiateResponse(negotiator, context); return(response); }
public DefaultRequestDispatcherFixture() { this.responseProcessors = new List <IResponseProcessor>(); this.routeResolver = A.Fake <IRouteResolver>(); this.routeInvoker = A.Fake <IRouteInvoker>(); this.negotiator = A.Fake <IResponseNegotiator>(); A.CallTo(() => this.routeInvoker.Invoke(A <Route> ._, A <CancellationToken> ._, A <DynamicDictionary> ._, A <NancyContext> ._)) .ReturnsLazily(async arg => { var routeResult = ((Route)arg.Arguments[0]).Invoke((DynamicDictionary)arg.Arguments[2], new CancellationToken()).ConfigureAwait(false); var x = await routeResult; return((Response)x); }); this.requestDispatcher = new DefaultRequestDispatcher(this.routeResolver, this.responseProcessors, this.routeInvoker, this.negotiator); var resolvedRoute = new ResolveResult { Route = new FakeRoute(), Parameters = DynamicDictionary.Empty, Before = null, After = null, OnError = null }; A.CallTo(() => this.routeResolver.Resolve(A <NancyContext> ._)).Returns(resolvedRoute); }
/// <summary> /// Executes content negotiation on current <see cref="HttpResponse"/>, utilizing an accepted media type if possible and defaulting to "application/json" if none found. /// </summary> /// <param name="response">Current <see cref="HttpResponse"/></param> /// <param name="obj">View model</param> /// <param name="cancellationToken"><see cref="CancellationToken"/></param> /// <returns><see cref="Task"/></returns> public static async Task Negotiate(this HttpResponse response, object obj, CancellationToken cancellationToken = default) { var negotiators = response.HttpContext.RequestServices.GetServices <IResponseNegotiator>(); IResponseNegotiator negotiator = null; MediaTypeHeaderValue.TryParseList(response.HttpContext.Request.Headers["Accept"], out var accept); if (accept != null) { var ordered = accept.OrderByDescending(x => x.Quality ?? 1); foreach (var acceptHeader in ordered) { negotiator = negotiators.FirstOrDefault(x => x.CanHandle(acceptHeader)); if (negotiator != null) { break; } } } if (negotiator == null) { negotiator = negotiators.FirstOrDefault(x => x.CanHandle(new MediaTypeHeaderValue("application/json"))); } await negotiator.Handle(response.HttpContext.Request, response, obj, cancellationToken); }
/// <summary> /// Constructor /// </summary> /// <param name="thuriaSerializer">Thuria Serializer</param> /// <param name="responseNegotiator">Nancy Response Negotiator</param> /// <param name="thuriaLogger">Thuria Logger</param> protected HeliumBaseModule(IThuriaSerializer thuriaSerializer, IResponseNegotiator responseNegotiator, IThuriaLogger thuriaLogger) : base("helium") { _responseNegotiator = responseNegotiator ?? throw new ArgumentNullException(nameof(responseNegotiator)); ThuriaSerializer = thuriaSerializer ?? throw new ArgumentNullException(nameof(thuriaSerializer)); ThuriaLogger = thuriaLogger ?? throw new ArgumentNullException(nameof(thuriaLogger)); }
public ErrorHandlingPipelines(IResponseNegotiator responseNegotiator, INancyErrorMap errorMap) { this.responseNegotiator = responseNegotiator; this.errorMap = errorMap; AfterRequest = new AfterPipeline(); BeforeRequest = new BeforePipeline(); OnError = new ErrorPipeline(); OnError += (ctx, ex) => { var nonAggregateException = ex.TrimAggregateException(); if (!errorMap.Contains(nonAggregateException.GetType())) { Logger.DebugFormat("Exception type not found in ErrorMap. Exception: {0}", nonAggregateException.GetType()); ctx.Response = DefaultError(ctx); } else { ctx.Response = Error(nonAggregateException, ctx); } return null; }; }
private static Response CreateNegotiatedResponse(NancyContext context, IResponseNegotiator responseNegotiator, Exception exception, HttpServiceError defaultError) { HttpServiceError httpServiceError = ExtractFromException(exception, defaultError); Negotiator negotiator = new Negotiator(context) .WithServiceError(httpServiceError); return(responseNegotiator.NegotiateResponse(negotiator, context)); }
private static Response CreateNegotiatedResponse(NancyContext context, IResponseNegotiator responseNegotiator, Exception exception) { HttpServiceError httpServiceError = HttpServiceErrorUtilities.ExtractFromException(exception, HttpServiceErrorDefinition.GeneralError); Negotiator negotiator = new Negotiator(context) .WithHttpServiceError(httpServiceError); return responseNegotiator.NegotiateResponse(negotiator, context); }
private static Response CreateNegotiatedResponse(NancyContext context, IResponseNegotiator responseNegotiator, Exception exception) { HttpServiceError httpServiceError = HttpServiceErrorUtilities.ExtractFromException(exception, HttpServiceErrorDefinition.GeneralError); Negotiator negotiator = new Negotiator(context) .WithHttpServiceError(httpServiceError); return(responseNegotiator.NegotiateResponse(negotiator, context)); }
private static Response CreateNegotiatedResponse(NancyContext context, IResponseNegotiator responseNegotiator, Exception exception, HttpServiceError defaultError) { HttpServiceError httpServiceError = ExtractFromException(exception, defaultError); Negotiator negotiator = new Negotiator(context) .WithServiceError(httpServiceError); return responseNegotiator.NegotiateResponse(negotiator, context); }
/// <summary> /// Initializes a new instance of the <see cref="DefaultRequestDispatcher"/> class, with /// the provided <paramref name="routeResolver"/>, <paramref name="responseProcessors"/> and <paramref name="routeInvoker"/>. /// </summary> /// <param name="routeResolver"></param> /// <param name="responseProcessors"></param> /// <param name="routeInvoker"></param> /// <param name="negotiator"></param> public DefaultRequestDispatcher(IRouteResolver routeResolver, IEnumerable<IResponseProcessor> responseProcessors, IRouteInvoker routeInvoker, IResponseNegotiator negotiator) { this.routeResolver = routeResolver; this.responseProcessors = responseProcessors; this.routeInvoker = routeInvoker; this.negotiator = negotiator; }
private static Response CreateNegotiatedResponse(NancyContext context, IResponseNegotiator responseNegotiator, Exception exception) { var (httpStatusCode, details) = HttpServiceErrorUtilities.ExtractFromException(exception); Negotiator negotiator = new Negotiator(context) .WithStatusCode(httpStatusCode) .WithModel(details); return responseNegotiator.NegotiateResponse(negotiator, context); }
/// <summary> /// Initializes a new instance of the <see cref="DefaultRequestDispatcher"/> class, with /// the provided <paramref name="routeResolver"/>, <paramref name="responseProcessors"/> and <paramref name="routeInvoker"/>. /// </summary> /// <param name="routeResolver"></param> /// <param name="responseProcessors"></param> /// <param name="routeInvoker"></param> /// <param name="negotiator"></param> public DefaultRequestDispatcher(IRouteResolver routeResolver, IEnumerable <IResponseProcessor> responseProcessors, IRouteInvoker routeInvoker, IResponseNegotiator negotiator) { this.routeResolver = routeResolver; this.responseProcessors = responseProcessors; this.routeInvoker = routeInvoker; this.negotiator = negotiator; }
public DefaultStatusCodeHandlerFixture() { var environment = new DefaultNancyEnvironment(); environment.Tracing( enabled: true, displayErrorTraces: true); this.responseNegotiator = A.Fake <IResponseNegotiator>(); this.statusCodeHandler = new DefaultStatusCodeHandler(this.responseNegotiator, environment); }
public DefaultStatusCodeHandlerFixture() { var environment = new DefaultNancyEnvironment(); environment.Tracing( enabled: true, displayErrorTraces: true); this.responseNegotiator = A.Fake<IResponseNegotiator>(); this.statusCodeHandler = new DefaultStatusCodeHandler(this.responseNegotiator, environment); }
public static void Enable(IPipelines pipelines, IResponseNegotiator responseNegotiator) { if (pipelines == null) { throw new ArgumentNullException("pipelines"); } if (responseNegotiator == null) { throw new ArgumentNullException("responseNegotiator"); } pipelines.OnError += (context, exception) => HandleException(context, exception, responseNegotiator); }
/// <summary> /// Initializes a new instance of the <see cref="DefaultStatusCodeHandler"/> type. /// </summary> /// <param name="responseNegotiator">The response negotiator.</param> public DefaultStatusCodeHandler(IResponseNegotiator responseNegotiator) { this.errorMessages = new Dictionary<HttpStatusCode, string> { { HttpStatusCode.NotFound, "The resource you have requested cannot be found." }, { HttpStatusCode.InternalServerError, "Something went horribly, horribly wrong while servicing your request." } }; this.errorPages = new Dictionary<HttpStatusCode, string> { { HttpStatusCode.NotFound, LoadResource("404.html") }, { HttpStatusCode.InternalServerError, LoadResource("500.html") } }; this.responseNegotiator = responseNegotiator; }
/// <summary> /// Initializes a new instance of the <see cref="DefaultStatusCodeHandler"/> type. /// </summary> /// <param name="responseNegotiator">The response negotiator.</param> public DefaultStatusCodeHandler(IResponseNegotiator responseNegotiator) { this.errorMessages = new Dictionary <HttpStatusCode, string> { { HttpStatusCode.NotFound, "The resource you have requested cannot be found." }, { HttpStatusCode.InternalServerError, "Something went horribly, horribly wrong while servicing your request." } }; this.errorPages = new Dictionary <HttpStatusCode, string> { { HttpStatusCode.NotFound, LoadResource("404.html") }, { HttpStatusCode.InternalServerError, LoadResource("500.html") } }; this.responseNegotiator = responseNegotiator; }
public static Response HandleException(NancyContext ctx, Exception ex, IResponseNegotiator responder) { LogException(ctx, ex); // Return AjaxError JSON if the client was making an AJAX request. Otherwise show an error page. var negotiator = new Negotiator(ctx); negotiator = negotiator.WithStatusCode(HttpStatusCode.InternalServerError) // Use this model as a JSON response if the client asked for application/json .WithMediaRangeModel("application/json", new AjaxError(AjaxError.InternalError, "Sorry, something went wrong when processing your request.")) // Use this model as the model for the view if anything other than JSON .WithModel(new ErrorViewModel(ex)) // Use this view for text/html .WithView("Error"); return responder.NegotiateResponse(negotiator, ctx); }
/// <summary> /// Initializes a new instance of the <see cref="NancyEngine"/> class. /// </summary> /// <param name="dispatcher">An <see cref="IRouteResolver"/> instance that will be used to resolve a route, from the modules, that matches the incoming <see cref="Request"/>.</param> /// <param name="contextFactory">A factory for creating contexts</param> /// <param name="statusCodeHandlers">Error handlers</param> /// <param name="requestTracing">The request tracing instance.</param> /// <param name="staticContentProvider">The provider to use for serving static content</param> /// <param name="negotiator">The response negotiator.</param> /// <param name="environment">An <see cref="INancyEnvironment"/> instance.</param> public NancyEngine(IRequestDispatcher dispatcher, INancyContextFactory contextFactory, IEnumerable <IStatusCodeHandler> statusCodeHandlers, IRequestTracing requestTracing, IStaticContentProvider staticContentProvider, IResponseNegotiator negotiator, INancyEnvironment environment) { if (dispatcher == null) { throw new ArgumentNullException("dispatcher", "The resolver parameter cannot be null."); } if (contextFactory == null) { throw new ArgumentNullException("contextFactory"); } if (statusCodeHandlers == null) { throw new ArgumentNullException("statusCodeHandlers"); } if (requestTracing == null) { throw new ArgumentNullException("requestTracing"); } if (staticContentProvider == null) { throw new ArgumentNullException("staticContentProvider"); } if (negotiator == null) { throw new ArgumentNullException("negotiator"); } this.dispatcher = dispatcher; this.contextFactory = contextFactory; this.statusCodeHandlers = statusCodeHandlers.ToArray(); this.requestTracing = requestTracing; this.staticContentProvider = staticContentProvider; this.negotiator = negotiator; this.engineDisposedCts = new CancellationTokenSource(); this.traceConfiguration = environment.GetValue <TraceConfiguration>(); }
/// <summary> /// Initializes a new instance of the <see cref="NancyEngine"/> class. /// </summary> /// <param name="dispatcher">An <see cref="IRouteResolver"/> instance that will be used to resolve a route, from the modules, that matches the incoming <see cref="Request"/>.</param> /// <param name="contextFactory">A factory for creating contexts</param> /// <param name="statusCodeHandlers">Error handlers</param> /// <param name="requestTracing">The request tracing instance.</param> /// <param name="staticContentProvider">The provider to use for serving static content</param> /// <param name="negotiator">The response negotiator.</param> /// <param name="environment">An <see cref="INancyEnvironment"/> instance.</param> public NancyEngine(IRequestDispatcher dispatcher, INancyContextFactory contextFactory, IEnumerable<IStatusCodeHandler> statusCodeHandlers, IRequestTracing requestTracing, IStaticContentProvider staticContentProvider, IResponseNegotiator negotiator, INancyEnvironment environment) { if (dispatcher == null) { throw new ArgumentNullException("dispatcher", "The resolver parameter cannot be null."); } if (contextFactory == null) { throw new ArgumentNullException("contextFactory"); } if (statusCodeHandlers == null) { throw new ArgumentNullException("statusCodeHandlers"); } if (requestTracing == null) { throw new ArgumentNullException("requestTracing"); } if (staticContentProvider == null) { throw new ArgumentNullException("staticContentProvider"); } if (negotiator == null) { throw new ArgumentNullException("negotiator"); } this.dispatcher = dispatcher; this.contextFactory = contextFactory; this.statusCodeHandlers = statusCodeHandlers.ToArray(); this.requestTracing = requestTracing; this.staticContentProvider = staticContentProvider; this.negotiator = negotiator; this.engineDisposedCts = new CancellationTokenSource(); this.traceConfiguration = environment.GetValue<TraceConfiguration>(); }
public NancyEngineFixture() { this.environment = new DefaultNancyEnvironment(); this.environment.Tracing( enabled: true, displayErrorTraces: true); this.resolver = A.Fake <IRouteResolver>(); this.response = new Response(); this.route = new FakeRoute(response); this.context = new NancyContext(); this.statusCodeHandler = A.Fake <IStatusCodeHandler>(); this.requestDispatcher = A.Fake <IRequestDispatcher>(); this.negotiator = A.Fake <IResponseNegotiator>(); A.CallTo(() => this.requestDispatcher.Dispatch(A <NancyContext> ._, A <CancellationToken> ._)) .Returns(Task.FromResult(new Response())); A.CallTo(() => this.statusCodeHandler.HandlesStatusCode(A <HttpStatusCode> .Ignored, A <NancyContext> .Ignored)).Returns(false); contextFactory = A.Fake <INancyContextFactory>(); A.CallTo(() => contextFactory.Create(A <Request> ._)).Returns(context); var resolveResult = new ResolveResult { Route = route, Parameters = DynamicDictionary.Empty, Before = null, After = null, OnError = null }; A.CallTo(() => resolver.Resolve(A <NancyContext> .Ignored)).Returns(resolveResult); var applicationPipelines = new Pipelines(); this.routeInvoker = A.Fake <IRouteInvoker>(); A.CallTo(() => this.routeInvoker.Invoke(A <Route> ._, A <CancellationToken> ._, A <DynamicDictionary> ._, A <NancyContext> ._)).ReturnsLazily(arg => { return(((Route)arg.Arguments[0]).Action.Invoke((DynamicDictionary)arg.Arguments[1], A <CancellationToken> ._).Result); }); this.engine = new NancyEngine(this.requestDispatcher, this.contextFactory, new[] { this.statusCodeHandler }, A.Fake <IRequestTracing>(), new DisabledStaticContentProvider(), this.negotiator, this.environment) { RequestPipelinesFactory = ctx => applicationPipelines }; }
/// <summary> /// Initializes a new instance of the <see cref="NancyEngine"/> class. /// </summary> /// <param name="dispatcher">An <see cref="IRouteResolver"/> instance that will be used to resolve a route, from the modules, that matches the incoming <see cref="Request"/>.</param> /// <param name="contextFactory">A factory for creating contexts</param> /// <param name="statusCodeHandlers">Error handlers</param> /// <param name="requestTracing">The request tracing instance.</param> /// <param name="staticContentProvider">The provider to use for serving static content</param> /// <param name="negotiator">The response negotiator.</param> public NancyEngine(IRequestDispatcher dispatcher, INancyContextFactory contextFactory, IEnumerable <IStatusCodeHandler> statusCodeHandlers, IRequestTracing requestTracing, IStaticContentProvider staticContentProvider, IResponseNegotiator negotiator) { if (dispatcher == null) { throw new ArgumentNullException("dispatcher", "The resolver parameter cannot be null."); } if (contextFactory == null) { throw new ArgumentNullException("contextFactory"); } if (statusCodeHandlers == null) { throw new ArgumentNullException("statusCodeHandlers"); } if (requestTracing == null) { throw new ArgumentNullException("requestTracing"); } if (staticContentProvider == null) { throw new ArgumentNullException("staticContentProvider"); } if (negotiator == null) { throw new ArgumentNullException("negotiator"); } this.dispatcher = dispatcher; this.contextFactory = contextFactory; this.statusCodeHandlers = statusCodeHandlers; this.requestTracing = requestTracing; this.staticContentProvider = staticContentProvider; this.negotiator = negotiator; }
/// <summary> /// Initializes a new instance of the <see cref="NancyEngine"/> class. /// </summary> /// <param name="dispatcher">An <see cref="IRouteResolver"/> instance that will be used to resolve a route, from the modules, that matches the incoming <see cref="Request"/>.</param> /// <param name="contextFactory">A factory for creating contexts</param> /// <param name="statusCodeHandlers">Error handlers</param> /// <param name="requestTracing">The request tracing instance.</param> /// <param name="staticContentProvider">The provider to use for serving static content</param> /// <param name="negotiator">The response negotiator.</param> public NancyEngine(IRequestDispatcher dispatcher, INancyContextFactory contextFactory, IEnumerable<IStatusCodeHandler> statusCodeHandlers, IRequestTracing requestTracing, IStaticContentProvider staticContentProvider, IResponseNegotiator negotiator) { if (dispatcher == null) { throw new ArgumentNullException("dispatcher", "The resolver parameter cannot be null."); } if (contextFactory == null) { throw new ArgumentNullException("contextFactory"); } if (statusCodeHandlers == null) { throw new ArgumentNullException("statusCodeHandlers"); } if (requestTracing == null) { throw new ArgumentNullException("requestTracing"); } if (staticContentProvider == null) { throw new ArgumentNullException("staticContentProvider"); } if (negotiator == null) { throw new ArgumentNullException("negotiator"); } this.dispatcher = dispatcher; this.contextFactory = contextFactory; this.statusCodeHandlers = statusCodeHandlers; this.requestTracing = requestTracing; this.staticContentProvider = staticContentProvider; this.negotiator = negotiator; }
public NancyEngineFixture() { this.environment = new DefaultNancyEnvironment(); this.environment.Tracing( enabled: true, displayErrorTraces: true); this.resolver = A.Fake<IRouteResolver>(); this.response = new Response(); this.route = new FakeRoute(response); this.context = new NancyContext(); this.statusCodeHandler = A.Fake<IStatusCodeHandler>(); this.requestDispatcher = A.Fake<IRequestDispatcher>(); this.negotiator = A.Fake<IResponseNegotiator>(); A.CallTo(() => this.requestDispatcher.Dispatch(A<NancyContext>._, A<CancellationToken>._)) .Returns(Task.FromResult(new Response())); A.CallTo(() => this.statusCodeHandler.HandlesStatusCode(A<HttpStatusCode>.Ignored, A<NancyContext>.Ignored)).Returns(false); contextFactory = A.Fake<INancyContextFactory>(); A.CallTo(() => contextFactory.Create(A<Request>._)).Returns(context); var resolveResult = new ResolveResult { Route = route, Parameters = DynamicDictionary.Empty, Before = null, After = null, OnError = null }; A.CallTo(() => resolver.Resolve(A<NancyContext>.Ignored)).Returns(resolveResult); var applicationPipelines = new Pipelines(); this.routeInvoker = A.Fake<IRouteInvoker>(); A.CallTo(() => this.routeInvoker.Invoke(A<Route>._, A<CancellationToken>._, A<DynamicDictionary>._, A<NancyContext>._)).ReturnsLazily(arg => { return ((Route)arg.Arguments[0]).Action.Invoke((DynamicDictionary)arg.Arguments[1], A<CancellationToken>._).Result; }); this.engine = new NancyEngine(this.requestDispatcher, this.contextFactory, new[] { this.statusCodeHandler }, A.Fake<IRequestTracing>(), new DisabledStaticContentProvider(), this.negotiator, this.environment) { RequestPipelinesFactory = ctx => applicationPipelines }; }
public static void Enable(IPipelines pipelines, IResponseNegotiator responseNegotiator, HttpServiceError defaultError) { if (pipelines == null) { throw new ArgumentNullException(nameof(pipelines)); } if (responseNegotiator == null) { throw new ArgumentNullException(nameof(responseNegotiator)); } if (defaultError == null) { throw new ArgumentNullException(nameof(defaultError)); } pipelines.OnError += (context, exception) => HandleException(context, exception, responseNegotiator, defaultError); }
public DefaultRequestDispatcherFixture() { this.responseProcessors = new List <IResponseProcessor>(); this.routeResolver = A.Fake <IRouteResolver>(); this.routeInvoker = A.Fake <IRouteInvoker>(); this.negotiator = A.Fake <IResponseNegotiator>(); A.CallTo(() => this.routeInvoker.Invoke(A <Route> ._, A <CancellationToken> ._, A <DynamicDictionary> ._, A <NancyContext> ._)).ReturnsLazily(arg => { var tcs = new TaskCompletionSource <Response>(); var actionResult = ((Route)arg.Arguments[0]).Action.Invoke(arg.Arguments[2], new CancellationToken()); if (actionResult.IsFaulted) { tcs.SetException(actionResult.Exception.InnerException); } else { tcs.SetResult(actionResult.Result); } return(tcs.Task); }); this.requestDispatcher = new DefaultRequestDispatcher(this.routeResolver, this.responseProcessors, this.routeInvoker, this.negotiator); var resolvedRoute = new ResolveResult { Route = new FakeRoute(), Parameters = DynamicDictionary.Empty, Before = null, After = null, OnError = null }; A.CallTo(() => this.routeResolver.Resolve(A <NancyContext> ._)).Returns(resolvedRoute); }
public DefaultRequestDispatcherFixture() { this.responseProcessors = new List<IResponseProcessor>(); this.routeResolver = A.Fake<IRouteResolver>(); this.routeInvoker = A.Fake<IRouteInvoker>(); this.negotiator = A.Fake<IResponseNegotiator>(); A.CallTo(() => this.routeInvoker.Invoke(A<Route>._, A<CancellationToken>._, A<DynamicDictionary>._, A<NancyContext>._)).ReturnsLazily(arg => { var tcs = new TaskCompletionSource<Response>(); var actionResult = ((Route)arg.Arguments[0]).Action.Invoke(arg.Arguments[2], new CancellationToken()); if (actionResult.IsFaulted) { tcs.SetException(actionResult.Exception.InnerException); } else { tcs.SetResult(actionResult.Result); } return tcs.Task; }); this.requestDispatcher = new DefaultRequestDispatcher(this.routeResolver, this.responseProcessors, this.routeInvoker, this.negotiator); var resolvedRoute = new ResolveResult { Route = new FakeRoute(), Parameters = DynamicDictionary.Empty, Before = null, After = null, OnError = null }; A.CallTo(() => this.routeResolver.Resolve(A<NancyContext>._)).Returns(resolvedRoute); }
/// <summary> /// Enable HttpProblemDetails support in the application /// </summary> /// <param name="pipelines">Application pipeline to hook into</param> /// <param name="responseNegotiator">An <see cref="IResponseNegotiator"/> instance.</param> public static void Enable(IPipelines pipelines, IResponseNegotiator responseNegotiator) { var httpProblemDetailsEnabled = pipelines.AfterRequest.PipelineItems.Any(ctx => ctx.Name == nameof(HttpProblemDetails)); if (!httpProblemDetailsEnabled) { pipelines.OnError.AddItemToEndOfPipeline((context, exception) => { var ex = HttpProblemDetailException.FromException(exception); if (ex == null) { return(context.Response); } var negotiator = new Negotiator(context) .WithContentType(GetContentTypeForContext(context)) .WithStatusCode(ex?.ProblemDetail?.Status ?? 0) .WithModel(ex.ProblemDetail); return(responseNegotiator.NegotiateResponse(negotiator, context)); }); } }
/// <summary> /// Initializes a new instance of the <see cref="StatusCodeHandler"/> class. /// </summary> /// <param name="viewRenderer"> /// The view renderer. /// </param> /// <param name="negotiator"> /// The response negotiator. /// </param> public StatusCodeHandler(IViewRenderer viewRenderer, IResponseNegotiator negotiator) { this.responseNegotiator = negotiator; }
public DefaultStatusCodeHandlerFixture() { this.responseNegotiator = A.Fake<IResponseNegotiator>(); this.statusCodeHandler = new DefaultStatusCodeHandler(this.responseNegotiator); }
public NotFoundErrorHandler(IResponseNegotiator responseNegotiator) { _defaultStatusCodeHandler = new DefaultStatusCodeHandler(responseNegotiator); }
public NotFoundStatusCodeHandler(IResponseNegotiator responseNegotiator) { this.responseNegotiator = responseNegotiator; }
private static Response HandleException(NancyContext context, Exception exception, IResponseNegotiator responseNegotiator) { LogException(context, exception); return(CreateNegotiatedResponse(context, responseNegotiator, exception)); }
public static void Enable(IPipelines pipelines, IResponseNegotiator responseNegotiator) { pipelines.OnError += (context, exception) => HandleException(context, exception, responseNegotiator); }
public ErrorStatusCodeHandler(IResponseNegotiator negotiator, IViewRenderer viewRenderer) { this.viewRenderer = viewRenderer; this.negotiator = negotiator; }
public ExceptionStatusCodeHandler(IResponseNegotiator responseNegotiator) { _responseNegotiator = responseNegotiator; }
/// <summary> /// Initializes a new instance of the <see cref="DefaultRouteInvoker"/> class. /// </summary> /// <param name="negotiator">The response negotiator.</param> public DefaultRouteInvoker(IResponseNegotiator negotiator) { this.negotiator = negotiator; }
/// <summary> /// Constructor /// </summary> /// <param name="heliumActorSystem">Helium Actor System</param> /// <param name="thuriaSerializer">Thuria Serializer</param> /// <param name="responseNegotiator">Nancy Response Negotiator</param> /// <param name="thuriaLogger">Thuria Logger</param> public HeliumInsertModule(IThuriaActorSystem heliumActorSystem, IThuriaSerializer thuriaSerializer, IResponseNegotiator responseNegotiator, IThuriaLogger thuriaLogger) : base(thuriaSerializer, responseNegotiator, thuriaLogger) { _heliumActorSystem = heliumActorSystem ?? throw new ArgumentNullException(nameof(heliumActorSystem)); Post("/insert", async(parameters, token) => await ProcessRequest()); ThuriaLogger.LogMessage(LogSeverity.Info, "Helium Insert ready to receive requests"); }
public DefaultRouteInvokerFixture() { this.responseNegotiator = A.Fake<IResponseNegotiator>(); this.invoker = new DefaultRouteInvoker(responseNegotiator); }
public StatusCodeHandler500(IResponseNegotiator responseNegotiator) { this.responseNegotiator = responseNegotiator; }
public ErrorStatusCodeHandler(IResponseNegotiator responseNegotiator) { this.responseNegotiator = responseNegotiator; }
private static Response HandleException(NancyContext context, Exception exception, IResponseNegotiator responseNegotiator, HttpServiceError defaultError) { LogException(context, exception); return(CreateNegotiatedResponse(context, responseNegotiator, exception, defaultError)); }
private static Response HandleException(NancyContext context, Exception exception, IResponseNegotiator responseNegotiator, HttpServiceError defaultError) { LogException(context, exception); return CreateNegotiatedResponse(context, responseNegotiator, exception, defaultError); }
public StatusCodeHandler404(IResponseNegotiator responseNegotiator) { _responseNegotiator = responseNegotiator; }
public DefaultStatusCodeHandler(IResponseNegotiator responseNegotiator) : base(responseNegotiator) { }
private static Response HandleException(NancyContext context, Exception exception, IResponseNegotiator responseNegotiator) { LogException(context, exception); return CreateNegotiatedResponse(context, responseNegotiator, exception); }
public PipelinesBuilder WithErrorHandling(IResponseNegotiator responseNegotiator, INancyErrorMap errorMap) { this.pipelinesDictionary.Add(1, () => new ErrorHandlingPipelines(responseNegotiator, errorMap)); return this; }
public DefaultRouteInvokerFixture() { this.responseNegotiator = A.Fake <IResponseNegotiator>(); this.invoker = new DefaultRouteInvoker(responseNegotiator); }