public void Should_add_negotiated_headers_to_response() { // Given var module = new ConfigurableNancyModule(with => { with.Get("/headers", x => { var context = new NancyContext { NegotiationContext = new NegotiationContext() }; var negotiator = new Negotiator(context); negotiator.WithHeader("foo", "bar"); return negotiator; }); }); var brower = new Browser(with => { with.ResponseProcessor<TestProcessor>(); with.Module(module); }); // When var response = brower.Get("/headers"); // Then Assert.True(response.Headers.ContainsKey("foo")); Assert.Equal("bar", response.Headers["foo"]); }
public void Should_add_negotiated_content_headers_to_response() { // Given var module = new ConfigurableNancyModule(with => { with.Get("/headers", (x, m) => { var context = new NancyContext { NegotiationContext = new NegotiationContext() }; var negotiator = new Negotiator(context); negotiator.WithContentType("text/xml"); return negotiator; }); }); var brower = new Browser(with => { with.ResponseProcessor<TestProcessor>(); with.Module(module); }); // When var response = brower.Get("/headers"); // Then Assert.Equal("text/xml", response.Context.Response.ContentType); }
public void Should_apply_default_accept_when_no_accept_header_sent() { // Given var browser = new Browser(with => { with.ResponseProcessor<TestProcessor>(); with.Module(new ConfigurableNancyModule(x => { x.Get("/", parameters => { var context = new NancyContext { NegotiationContext = new NegotiationContext() }; var negotiator = new Negotiator(context); return negotiator; }); })); }); // When var response = browser.Get("/"); // Then Assert.Equal(HttpStatusCode.OK, response.StatusCode); }
private static void AddNegotiatedHeaders(Negotiator negotiator, Response response) { foreach (var header in negotiator.NegotiationContext.Headers) { response.Headers[header.Key] = header.Value; } }
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); }
public void Handle(HttpStatusCode statusCode, NancyContext context) { context.NegotiationContext = new NegotiationContext(); Negotiator negotiator = new Negotiator(context) .WithHttpServiceError(HttpServiceErrorDefinition.InternalServerError); context.Response = responseNegotiator.NegotiateResponse(negotiator, context); }
public void Handle(HttpStatusCode statusCode, NancyContext context) { context.NegotiationContext = new NegotiationContext(); Negotiator negotiator = new Negotiator(context) .WithServiceError(new NotFoundError(context.Request.Path)); context.Response = responseNegotiator.NegotiateResponse(negotiator, context); }
public void Handle(HttpStatusCode statusCode, NancyContext context) { context.NegotiationContext = new NegotiationContext(); Negotiator negotiator = new Negotiator(context) .WithStatusCode(HttpServiceErrorDefinition.NotFoundError.HttpStatusCode) .WithModel(HttpServiceErrorDefinition.NotFoundError.ServiceErrorModel); context.Response = responseNegotiator.NegotiateResponse(negotiator, context); }
private Response DefaultError(NancyContext ctx) { var defaultErrorRepresentation = new ErrorRepresentation(HttpStatusCode.InternalServerError, DefaultErrorCode); defaultErrorRepresentation.Message = DefaultErrorMessage; var negotiator = new Negotiator(ctx).WithStatusCode(HttpStatusCode.InternalServerError).WithModel(defaultErrorRepresentation); return responseNegotiator.NegotiateResponse(negotiator, ctx); }
/// <summary> /// Gets a <see cref="NegotiationContext"/> based on the given result and context. /// </summary> /// <param name="routeResult">The route result.</param> /// <param name="context">The context.</param> /// <returns>A <see cref="NegotiationContext"/>.</returns> private static NegotiationContext GetNegotiationContext(object routeResult, NancyContext context) { var negotiator = routeResult as Negotiator; if (negotiator == null) { context.WriteTraceLog(sb => sb.AppendFormat("[DefaultResponseNegotiator] Wrapping result of type {0} in negotiator\n", routeResult.GetType())); negotiator = new Negotiator(context).WithModel(routeResult); } return(negotiator.NegotiationContext); }
private Response Error(Exception rootException, NancyContext ctx) { var errorMapping = errorMap[rootException.GetType()]; var errorRepresentation = errorMapping.Representation; if (string.IsNullOrEmpty(errorRepresentation.Message)) { errorRepresentation.Message = rootException.Message; } var negotiator = new Negotiator(ctx).WithStatusCode(errorMapping.HttpStatusCode).WithModel(errorRepresentation); return responseNegotiator.NegotiateResponse(negotiator, ctx); }
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); }
public void Handle(HttpStatusCode statusCode, NancyContext context) { var response = new Negotiator(context); Error error = null; if (context.Items.ContainsKey("OnErrorException")) { var exception = context.Items["OnErrorException"] as Exception; error = new Error { ErrorMessage = exception.Message, FullException = exception.ToString() }; } response.WithModel(new ErrorPageViewModel { Title = "Sorry, something went wrong", Summary = error == null ? "An unexpected error occurred." : error.ErrorMessage, Details = error == null ? null : error.FullException // TODO: Obey "ShowFullErrors" flag in config }).WithStatusCode(statusCode).WithView("Error"); var errorresponse = responseNegotiator.NegotiateResponse(response, context); string s = ""; context.Response = errorresponse; }
public void Should_set_reason_phrase_on_response() { // Given var module = new ConfigurableNancyModule(with => { with.Get("/customPhrase", (x, m) => { var context = new NancyContext(); var negotiator = new Negotiator(context); negotiator.WithReasonPhrase("The test is passing!").WithStatusCode(404); return negotiator; }); }); var browser = new Browser(with => { with.StatusCodeHandler<DefaultStatusCodeHandler>(); with.ResponseProcessor<TestProcessor>(); with.Module(module); }); // When var response = browser.Get("/customPhrase", with => with.Accept("application/json")); // Then Assert.Equal("The test is passing!", response.ReasonPhrase); }
private Tuple<string, IEnumerable<Tuple<IResponseProcessor, ProcessorMatch>>>[] GetCompatibleHeaders(NancyContext context, Negotiator negotiator) { var coercedAcceptHeaders = this.GetCoercedAcceptHeaders(context).ToArray(); List<Tuple<string, decimal>> acceptHeaders; var permissableMediaRanges = negotiator.NegotiationContext.PermissableMediaRanges; if (permissableMediaRanges.Any(mr => mr.IsWildcard)) { acceptHeaders = coercedAcceptHeaders .Where(header => header.Item2 > 0m) .ToList(); } else { acceptHeaders = coercedAcceptHeaders.Where(header => header.Item2 > 0m) .SelectMany(header => permissableMediaRanges.Where(mr => mr.Matches(header.Item1)).Select(mr => Tuple.Create(mr.ToString(), header.Item2))) .ToList(); } return (from header in acceptHeaders let compatibleProcessors = (IEnumerable<Tuple<IResponseProcessor, ProcessorMatch>>)GetCompatibleProcessorsByHeader(header.Item1, negotiator.NegotiationContext.GetModelForMediaRange(header.Item1), context) where compatibleProcessors != null select new Tuple<string, IEnumerable<Tuple<IResponseProcessor, ProcessorMatch>>>( header.Item1, compatibleProcessors )).ToArray(); }
private static Response NegotiateResponse(IEnumerable<Tuple<string, IEnumerable<Tuple<IResponseProcessor, ProcessorMatch>>>> compatibleHeaders, object model, Negotiator negotiator, NancyContext context) { foreach (var compatibleHeader in compatibleHeaders) { var prioritizedProcessors = compatibleHeader.Item2 .OrderByDescending(x => x.Item2.ModelResult) .ThenByDescending(x => x.Item2.RequestedContentTypeResult); foreach (var prioritizedProcessor in prioritizedProcessors) { var processorType = prioritizedProcessor.Item1.GetType(); context.WriteTraceLog(sb => sb.AppendFormat("[DefaultRouteInvoker] Invoking processor: {0}\n", processorType)); var response = SafeInvokeResponseProcessor(prioritizedProcessor.Item1, compatibleHeader.Item1, negotiator.NegotiationContext.GetModelForMediaRange(compatibleHeader.Item1), context); if (response != null) { return response; } } } return null; }
private static Negotiator GetNegotiator(object routeResult, NancyContext context) { var negotiator = routeResult as Negotiator; if (negotiator == null) { context.WriteTraceLog(sb => sb.AppendFormat("[DefaultRouteInvoker] Wrapping result of type {0} in negotiator\n", routeResult.GetType())); negotiator = new Negotiator(context); negotiator.WithModel(routeResult); } return negotiator; }
private static Func<dynamic, NancyModule, dynamic> CreateNegotiatedResponse(Action<Negotiator> action = null) { return (parameters, module) => { var negotiator = new Negotiator(module.Context); if (action != null) { action.Invoke(negotiator); } return negotiator; }; }
public void Should_set_reason_phrase_on_response() { // Given var module = new ConfigurableNancyModule(with => { with.Get("/customPhrase", (x, m) => { var context = new NancyContext(); var negotiator = new Negotiator(context); negotiator.WithReasonPhrase("The test is passing!"); return negotiator; }); }); var brower = new Browser(with => { with.ResponseProcessor<TestProcessor>(); with.Module(module); }); // When var response = brower.Get("/customPhrase"); // Then Assert.Equal("The test is passing!", response.ReasonPhrase); }
public void Should_override_with_extension() { // Given var browser = new Browser(with => { with.ResponseProcessor<TestProcessor>(); with.Module(new ConfigurableNancyModule(x => { x.Get("/test", (parameters, module) => { var context = new NancyContext(); var negotiator = new Negotiator(context); return negotiator; }); })); }); // When var response = browser.Get("/test.foo", with => { with.Header("User-Agent", "Mozilla/5.0 (Windows; U; Windows NT 5.1; ru-RU) AppleWebKit/533.19.4 (KHTML, like Gecko) Version/5.0.3 Safari/533.19.4"); with.Accept("application/xml", 0.9m); with.Accept("text/html", 0.9m); }); // Then Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.True(response.Body.AsString().Contains("foo/bar"), "Media type mismatch"); }
public void Should_boost_html_priority_if_set_to_the_same_priority_as_others() { // Given var browser = new Browser(with => { with.ResponseProcessor<TestProcessor>(); with.Module(new ConfigurableNancyModule(x => { x.Get("/", parameters => { var context = new NancyContext { NegotiationContext = new NegotiationContext() }; var negotiator = new Negotiator(context); negotiator.WithAllowedMediaRange("application/xml"); negotiator.WithAllowedMediaRange("text/html"); return negotiator; }); })); }); // When var response = browser.Get("/", with => { with.Header("User-Agent", "Mozilla/5.0 (Windows; U; Windows NT 5.1; ru-RU) AppleWebKit/533.19.4 (KHTML, like Gecko) Version/5.0.3 Safari/533.19.4"); with.Accept("application/xml", 0.9m); with.Accept("text/html", 0.9m); }); // Then Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.True(response.Body.AsString().Contains("text/html"), "Media type mismatch"); }
private static Func<dynamic, dynamic> CreateNegotiatedResponse(Action<Negotiator> action = null) { var context = new NancyContext { NegotiationContext = new NegotiationContext() }; var negotiator = new Negotiator(context); if (action != null) { action.Invoke(negotiator); } return parameters => negotiator; }
private Tuple<string, IEnumerable<Tuple<IResponseProcessor, ProcessorMatch>>>[] GetCompatibleHeaders(IEnumerable<Tuple<string, decimal>> coercedAcceptHeaders, NancyContext context, Negotiator negotiator) { List<Tuple<string, decimal>> acceptHeaders; var permissableMediaRanges = negotiator.NegotiationContext.PermissableMediaRanges; if (permissableMediaRanges.Any(mr => mr.IsWildcard)) { acceptHeaders = coercedAcceptHeaders .Where(header => header.Item2 > 0m) .ToList(); } else { acceptHeaders = coercedAcceptHeaders.Where(header => header.Item2 > 0m) .SelectMany(header => permissableMediaRanges.Where(mr => mr.Matches(header.Item1)).Select(mr => Tuple.Create(mr.ToString(), header.Item2))) .ToList(); } return this.GetCompatibleProcessors(acceptHeaders, negotiator, context).ToArray(); }
public void Should_ignore_stupid_browsers_that_ask_for_xml() { // Given var browser = new Browser(with => { with.ResponseProcessor<TestProcessor>(); with.Module(new ConfigurableNancyModule(x => { x.Get("/", parameters => { var context = new NancyContext { NegotiationContext = new NegotiationContext() }; var negotiator = new Negotiator(context); negotiator.WithAllowedMediaRange("application/xml"); negotiator.WithAllowedMediaRange("text/html"); return negotiator; }); })); }); // When var response = browser.Get("/", with => { with.Header("User-Agent", "Mozilla/5.0 (Windows; U; MSIE 7.0; Windows NT 6.0; en-US)"); with.Accept("application/xml", 1.0m); with.Accept("application/xhtml+xml", 1.0m); with.Accept("*/*", 0.9m); }); // Then Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.True(response.Body.AsString().Contains("text/html"), "Media type mismatch"); }
private static void CheckForContentTypeHeader(Negotiator negotiator, Response response) { if (negotiator.NegotiationContext.Headers.ContainsKey("Content-Type")) { response.ContentType = negotiator.NegotiationContext.Headers["Content-Type"]; negotiator.NegotiationContext.Headers.Remove("Content-Type"); } }
private IEnumerable<Tuple<string, IEnumerable<Tuple<IResponseProcessor, ProcessorMatch>>>> GetCompatibleProcessors(IEnumerable<Tuple<string, decimal>> acceptHeaders, Negotiator negotiator, NancyContext context) { foreach (var header in acceptHeaders) { var compatibleProcessors = (IEnumerable<Tuple<IResponseProcessor, ProcessorMatch>>)this.GetCompatibleProcessorsByHeader( header.Item1, negotiator.NegotiationContext.GetModelForMediaRange(header.Item1), context); if (compatibleProcessors.Any()) { yield return new Tuple<string, IEnumerable<Tuple<IResponseProcessor, ProcessorMatch>>>( header.Item1, compatibleProcessors ); } } }