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);
}
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 NotFoundStatusCodeHandler(IResponseNegotiator responseNegotiator)
{
this.responseNegotiator = responseNegotiator;
}
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;
}
/// <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;
}
public ErrorStatusCodeHandler(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);
}
