public void HandleRequest_should_allow_module_after_hook_to_add_items_to_context() { // Given var route = new FakeRoute(); var before = new BeforePipeline(); before += ctx => null; var after = new AfterPipeline(); after += ctx => ctx.Items.Add("RoutePostReq", new object()); var resolvedRoute = new ResolveResult( route, DynamicDictionary.Empty, before, after, null); A.CallTo(() => this.routeResolver.Resolve(A<NancyContext>.Ignored)).Returns(resolvedRoute); var context = new NancyContext { Request = new Request("GET", "/", "http") }; // When this.requestDispatcher.Dispatch(context, new CancellationToken()); // Then context.Items.ContainsKey("RoutePostReq").ShouldBeTrue(); }
public NancyEngineFixture() { this.resolver = A.Fake<IRouteResolver>(); this.response = new Response(); this.route = new FakeRoute(response); this.context = new NancyContext(); this.errorHandler = A.Fake<IErrorHandler>(); this.requestDispatcher = A.Fake<IRequestDispatcher>(); A.CallTo(() => this.requestDispatcher.Dispatch(A<NancyContext>._)).Invokes(x => this.context.Response = new Response()); A.CallTo(() => errorHandler.HandlesStatusCode(A<HttpStatusCode>.Ignored, A<NancyContext>.Ignored)).Returns(false); contextFactory = A.Fake<INancyContextFactory>(); A.CallTo(() => contextFactory.Create()).Returns(context); A.CallTo(() => resolver.Resolve(A<NancyContext>.Ignored)).Returns(new ResolveResult(route, DynamicDictionary.Empty, null, null, null)); var applicationPipelines = new Pipelines(); this.routeInvoker = A.Fake<IRouteInvoker>(); A.CallTo(() => this.routeInvoker.Invoke(A<Route>._, A<DynamicDictionary>._, A<NancyContext>._)).ReturnsLazily(arg => { return (Response)((Route)arg.Arguments[0]).Action.Invoke((DynamicDictionary)arg.Arguments[1]); }); this.engine = new NancyEngine(this.requestDispatcher, contextFactory, new[] { this.errorHandler }, A.Fake<IRequestTracing>()) { RequestPipelinesFactory = ctx => applicationPipelines }; }
public NancyEngineFixture() { 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.diagnosticsConfiguration = new DiagnosticsConfiguration(); A.CallTo(() => this.requestDispatcher.Dispatch(A<NancyContext>._, A<CancellationToken>._)).Invokes((x) => this.context.Response = 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>(), this.diagnosticsConfiguration, new DisabledStaticContentProvider()) { RequestPipelinesFactory = ctx => applicationPipelines }; }
private static Func<dynamic, CancellationToken, Task<dynamic>> Wrap( FakeRoute route, Func<dynamic, CancellationToken, Task<dynamic>> action) { return (parameters, token) => { route.ParametersUsedToInvokeAction = parameters; route.ActionWasInvoked = true; var tcs = new TaskCompletionSource<dynamic>(); try { var result = action.Invoke(parameters, token); tcs.SetResult(result.Result); } catch (Exception e) { tcs.SetException(e); } return tcs.Task; }; }
public NancyEngineFixture() { this.resolver = A.Fake<IRouteResolver>(); this.route = new FakeRoute(); A.CallTo(() => resolver.Resolve(A<Request>.Ignored, A<IRouteCache>.Ignored.Argument)).Returns(route); this.engine = new NancyEngine(resolver, A.Fake<IRouteCache>()); }
private static Func<dynamic, CancellationToken, Task<dynamic>> Wrap( FakeRoute route, Func<dynamic, CancellationToken, Task<dynamic>> action) { return (parameters, token) => { route.ParametersUsedToInvokeAction = parameters; route.ActionWasInvoked = true; return action.Invoke(parameters, token); }; }
public void Should_invoke_route_with_provided_parameters() { // Given var parameters = new DynamicDictionary(); var route = new FakeRoute(10); var context = new NancyContext(); // When this.invoker.Invoke(route, new CancellationToken(), parameters, context); // Then Assert.Same(route.ParametersUsedToInvokeAction, parameters); }
public void Should_return_response_when_route_returns_status_code() { // Given var parameters = new DynamicDictionary(); var route = new FakeRoute(HttpStatusCode.OK); var context = new NancyContext(); // When var result = this.invoker.Invoke(route, parameters, context); // Then Assert.IsType<Response>(result); }
public void Should_log_the_reason_for_early_exits() { // Given var response = new Response(); var route = new FakeRoute((c, t) => { throw new RouteExecutionEarlyExitException(response, "Reason Testing"); }); var parameters = new DynamicDictionary(); var context = new NancyContext { Trace = new RequestTrace(true) }; // When var result = this.invoker.Invoke(route, new CancellationToken(), parameters, context); // Then context.Trace.TraceLog.ToString().ShouldContain("Reason Testing"); }
public void Should_handle_RouteExecutionEarlyExitException_gracefully() { // Given var response = new Response(); var route = new FakeRoute((c, t) => { throw new RouteExecutionEarlyExitException(response); }); var parameters = new DynamicDictionary(); var context = new NancyContext(); // When var result = this.invoker.Invoke(route, new CancellationToken(), parameters, context); // Then result.ShouldBeSameAs(response); }
public NancyEngineFixture() { this.resolver = A.Fake<IRouteResolver>(); this.response = new Response(); this.route = new FakeRoute(response); this.context = new NancyContext(); contextFactory = A.Fake<INancyContextFactory>(); A.CallTo(() => contextFactory.Create()).Returns(context); A.CallTo(() => resolver.Resolve(A<NancyContext>.Ignored, A<IRouteCache>.Ignored.Argument)).Returns(new ResolveResult(route, DynamicDictionary.Empty, null, null)); this.engine = new NancyEngine(resolver, A.Fake<IRouteCache>(), contextFactory); }
public void Should_return_response_when_route_returns_action() { // Given Action<Stream> action = s => { }; var parameters = new DynamicDictionary(); var route = new FakeRoute(action); var context = new NancyContext(); // When var result = this.invoker.Invoke(route, parameters, context); // Then Assert.IsType<Response>(result); }
public async Task Should_invoke_module_before_hook_followed_by_resolved_route_followed_by_module_after_hook() { // Given var capturedExecutionOrder = new List<string>(); var expectedExecutionOrder = new[] { "Prehook", "RouteInvoke", "Posthook" }; var route = new FakeRoute { Action = (parameters, token) => { capturedExecutionOrder.Add("RouteInvoke"); return Task.FromResult<object>(null); } }; var before = new BeforePipeline(); before += (ctx) => { capturedExecutionOrder.Add("Prehook"); return null; }; var after = new AfterPipeline(); after += (ctx) => { capturedExecutionOrder.Add("Posthook"); }; var resolvedRoute = new ResolveResult { Route = route, Parameters = DynamicDictionary.Empty, Before = before, After = after, OnError = null }; A.CallTo(() => this.routeResolver.Resolve(A<NancyContext>.Ignored)).Returns(resolvedRoute); var context = new NancyContext { Request = new Request("GET", "/", "http") }; // When await this.requestDispatcher.Dispatch(context, new CancellationToken()); // Then capturedExecutionOrder.Count().ShouldEqual(3); capturedExecutionOrder.SequenceEqual(expectedExecutionOrder).ShouldBeTrue(); }
public NancyEngineFixture() { this.resolver = A.Fake<IRouteResolver>(); this.response = new Response(); this.route = new FakeRoute(response); this.context = new NancyContext(); this.errorHandler = A.Fake<IErrorHandler>(); A.CallTo(() => errorHandler.HandlesStatusCode(A<HttpStatusCode>.Ignored)).Returns(false); contextFactory = A.Fake<INancyContextFactory>(); A.CallTo(() => contextFactory.Create()).Returns(context); A.CallTo(() => resolver.Resolve(A<NancyContext>.Ignored, A<IRouteCache>.Ignored)).Returns(new ResolveResult(route, DynamicDictionary.Empty, null, null)); this.engine = new NancyEngine(resolver, A.Fake<IRouteCache>(), contextFactory, this.errorHandler); }
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>(); this.engine = new NancyEngine(this.requestDispatcher, this.contextFactory, new[] { this.statusCodeHandler }, A.Fake<IRequestTracing>(), new DisabledStaticContentProvider(), this.negotiator, this.environment) { RequestPipelinesFactory = ctx => applicationPipelines }; }
public NancyEngineFixture() { this.resolver = A.Fake<IRouteResolver>(); this.response = new Response(); this.route = new FakeRoute(response); this.context = new NancyContext(); this.errorHandler = A.Fake<IErrorHandler>(); A.CallTo(() => errorHandler.HandlesStatusCode(A<HttpStatusCode>.Ignored, A<NancyContext>.Ignored)).Returns(false); contextFactory = A.Fake<INancyContextFactory>(); A.CallTo(() => contextFactory.Create()).Returns(context); A.CallTo(() => resolver.Resolve(A<NancyContext>.Ignored)).Returns(new ResolveResult(route, DynamicDictionary.Empty, null, null)); var applicationPipelines = new Pipelines(); this.engine = new NancyEngine(resolver, contextFactory, new[] { this.errorHandler }, A.Fake<IRequestTracing>()) { RequestPipelinesFactory = ctx => applicationPipelines }; }
public async Task Should_invoke_module_onerror_hook_when_module_after_hook_throws_exception() { // Given var capturedExecutionOrder = new List<string>(); var expectedExecutionOrder = new[] { "Posthook", "OnErrorHook" }; var route = new FakeRoute { Action = (parameters, ct) => Task.FromResult<object>(null) }; var before = new BeforePipeline(); before += ctx => null; var after = new AfterPipeline(); after += ctx => { capturedExecutionOrder.Add("Posthook"); throw new Exception("Posthook"); }; var resolvedRoute = new ResolveResult( route, DynamicDictionary.Empty, before, after, (ctx, ex) => { capturedExecutionOrder.Add("OnErrorHook"); return new Response(); }); A.CallTo(() => this.routeResolver.Resolve(A<NancyContext>.Ignored)).Returns(resolvedRoute); var context = new NancyContext { Request = new Request("GET", "/", "http") }; // When await this.requestDispatcher.Dispatch(context, new CancellationToken()); // Then capturedExecutionOrder.Count().ShouldEqual(2); capturedExecutionOrder.SequenceEqual(expectedExecutionOrder).ShouldBeTrue(); }
public async Task Should_set_the_context_resolved_route_from_resolve_result() { // Given const string expectedPath = "/the/path"; var context = new NancyContext { Request = new FakeRequest("GET", expectedPath) }; var expectedRoute = new FakeRoute(); var resolveResult = new ResolveResult( expectedRoute, new DynamicDictionary(), null, null, null); A.CallTo(() => this.routeResolver.Resolve(context)).Returns(resolveResult); // When await this.requestDispatcher.Dispatch(context, new CancellationToken()); // Then context.ResolvedRoute.ShouldBeSameAs(expectedRoute); }
public async Task Should_allow_module_after_hook_to_change_response() { // Given var before = new BeforePipeline(); before += ctx => null; var response = new Response(); Func<NancyContext, Response> moduleAfterHookResponse = ctx => response; var after = new AfterPipeline(); after += ctx => { ctx.Response = moduleAfterHookResponse(ctx); }; var route = new FakeRoute(); var resolvedRoute = new ResolveResult( route, DynamicDictionary.Empty, before, after, null); A.CallTo(() => this.routeResolver.Resolve(A<NancyContext>.Ignored)).Returns(resolvedRoute); var context = new NancyContext { Request = new Request("GET", "/", "http") }; // When await this.requestDispatcher.Dispatch(context, new CancellationToken()); // Then context.Response.ShouldBeSameAs(response); }
public async Task Should_not_invoke_resolved_route_if_module_before_hook_returns_response_but_should_invoke_module_after_hook() { // Given var capturedExecutionOrder = new List<string>(); var expectedExecutionOrder = new[] { "Prehook", "Posthook" }; var route = new FakeRoute { Action = (parameters, token) => { capturedExecutionOrder.Add("RouteInvoke"); return null; } }; var before = new BeforePipeline(); before += ctx => { capturedExecutionOrder.Add("Prehook"); return new Response(); }; var after = new AfterPipeline(); after += ctx => capturedExecutionOrder.Add("Posthook"); var resolvedRoute = new ResolveResult( route, DynamicDictionary.Empty, before, after, null); A.CallTo(() => this.routeResolver.Resolve(A<NancyContext>.Ignored)).Returns(resolvedRoute); var context = new NancyContext { Request = new Request("GET", "/", "http") }; // When await this.requestDispatcher.Dispatch(context, new CancellationToken()); // Then capturedExecutionOrder.Count().ShouldEqual(2); capturedExecutionOrder.SequenceEqual(expectedExecutionOrder).ShouldBeTrue(); }
public void Should_return_response_when_route_returns_status_code() { // Given var parameters = new DynamicDictionary(); var route = new FakeRoute(HttpStatusCode.OK); var context = new NancyContext { Trace = new DefaultRequestTrace { TraceLog = new DefaultTraceLog() } }; // When var result = this.invoker.Invoke(route, new CancellationToken(), parameters, context).Result; // Then Assert.IsType<Response>(result); }
public void Should_return_response_from_module_before_hook_when_not_null() { // Given var expectedResponse = new Response(); Func<NancyContext, Response> moduleBeforeHookResponse = ctx => expectedResponse; var before = new BeforePipeline(); before += moduleBeforeHookResponse; var after = new AfterPipeline(); after += ctx => { }; var route = new FakeRoute(); var resolvedRoute = new ResolveResult( route, DynamicDictionary.Empty, before, after, null); A.CallTo(() => this.routeResolver.Resolve(A<NancyContext>.Ignored)).Returns(resolvedRoute); var context = new NancyContext { Request = new Request("GET", "/", "http") }; // When this.requestDispatcher.Dispatch(context, new CancellationToken()); // Then context.Response.ShouldBeSameAs(expectedResponse); }
public void Should_rethrow_exception_when_onerror_hook_does_return_response() { // Given var route = new FakeRoute { Action = (parameters, ct) => { throw new Exception(); } }; var before = new BeforePipeline(); before += ctx => null; var after = new AfterPipeline(); after += ctx => { }; var resolvedRoute = new ResolveResult( route, DynamicDictionary.Empty, before, after, (ctx, ex) => { return null; }); A.CallTo(() => this.routeResolver.Resolve(A<NancyContext>.Ignored)).Returns(resolvedRoute); var context = new NancyContext { Request = new Request("GET", "/", "http") }; //When // Then Assert.Throws<Exception>(() => this.requestDispatcher.Dispatch(context, new CancellationToken())); }
public void Should_return_response_when_route_returns_string() { // Given var parameters = new DynamicDictionary(); var route = new FakeRoute("Hello World"); var context = new NancyContext(); // When var result = this.invoker.Invoke(route, new CancellationToken(), parameters, context); // Then Assert.IsType<Response>(result); }
public async Task Should_not_rethrow_exception_when_onerror_hook_returns_response() { // Given var route = new FakeRoute { Action = (parameters, ct) => TaskHelpers.GetFaultedTask<dynamic>(new Exception()) }; var before = new BeforePipeline(); before += ctx => null; var after = new AfterPipeline(); after += ctx => { }; var resolvedRoute = new ResolveResult( route, DynamicDictionary.Empty, before, after, (ctx, ex) => new Response()); A.CallTo(() => this.routeResolver.Resolve(A<NancyContext>.Ignored)).Returns(resolvedRoute); var context = new NancyContext { Request = new Request("GET", "/", "http") }; //When var exception = await RecordAsync.Exception(async () => await this.requestDispatcher.Dispatch(context, new CancellationToken())); // Then exception.ShouldBeNull(); }
public async Task should_preserve_stacktrace_when_rethrowing_the_excption() { // Given var route = new FakeRoute { Action = (o, ct) => BrokenMethod() }; var before = new BeforePipeline(); before += ctx => null; var after = new AfterPipeline(); after += ctx => { }; var resolvedRoute = new ResolveResult( route, DynamicDictionary.Empty, before, after, (ctx, ex) => null); A.CallTo(() => this.routeResolver.Resolve(A<NancyContext>.Ignored)).Returns(resolvedRoute); var context = new NancyContext { Request = new Request("GET", "/", "http") }; var exception = await RecordAsync.Exception(async () => await this.requestDispatcher.Dispatch(context, new CancellationToken())); exception.StackTrace.ShouldContain("BrokenMethod"); }
public void Should_invoke_response_negotiator() { // Given var model = new Person { FirstName = "First", LastName = "Last" }; var route = new FakeRoute(model); var parameters = new DynamicDictionary(); var context = new NancyContext { Trace = new DefaultRequestTrace() }; // When var result = this.invoker.Invoke(route, new CancellationToken(), parameters, context).Result; // Then A.CallTo(() => this.responseNegotiator.NegotiateResponse(model, context)).MustHaveHappened(); }