public void IsLocal_should_return_false_if_urlString_is_empty()
        {
            // Given when
            var request = new FakeRequest("GET", string.Empty, string.Empty, string.Empty);

            // Then
            Assert.False(request.IsLocal());
        }
        public void IsAjaxRequest_should_return_false_if_request_is_not_ajax()
        {
            // Given when
            var request = new FakeRequest("POST", "/");

            // Then
            Assert.False(request.IsAjaxRequest());
        }
 public void IsLocal_should_return_true_if_userHostAddr_is_localhost_IPV4()
 {
     // Given when
     var request = new FakeRequest("POST", "/", string.Empty, "127.0.0.1");
     request.Url.HostName = "localhost";
     
     // Then
     Assert.True(request.IsLocal());
 }
        public void IsLocal_should_return_false_if_userHostAddr_is_not_localhost()
        {
            // Given when
            var request = new FakeRequest("GET", "/", string.Empty, "86.13.73.12");
            request.Url.HostName = "anotherhost";

            // Then
            Assert.False(request.IsLocal());
        }
        public void IsAjaxRequest_should_return_true_if_request_is_ajax()
        {
            // Given
            var headers =
                new Dictionary<string, IEnumerable<string>>
                    {
                        { "X-Requested-With", new[] { "XMLHttpRequest" } }
                    };

            // When
            var request = new FakeRequest("POST", "/", headers);

            // Then
            Assert.True(request.IsAjaxRequest());
        }
        public void StoringArbitraryData(OwinEnv owinEnironment)
        {
            var route = new Route("GET", "/customers/show/{id}", App);

            route.Data["CacheOptions"] = new CacheOptions(/* options */);

            var router = new Router();

            router.AddRoute(route);

            var result       = router.Resolve(FakeRequest.Get("/customers/show/{id}"));
            var cacheOptions = (CacheOptions)route.Data["CacheOptions"];

            // Add Caching Options to HTTP-Header

            result.Route.OwinAction.Invoke(owinEnironment);
        }
        public void Should_return_methodnotallowedroute_with_path_set_to_request_uri_when_matched_route_was_for_wrong_request_method()
        {
            // Given
            var request = new FakeRequest("POST", "/foo/bar");
            var context = new NancyContext {
                Request = request
            };
            var resolver = CreateResolver(x => x.AddGetRoute("/foo/bar"));

            // When
            var route = resolver.Resolve(context).Item1;

            // Then
            route.ShouldNotBeNull();
            route.ShouldBeOfType <MethodNotAllowedRoute>();
            route.Description.Path.ShouldEqual(request.Path);
        }
        public void Should_allow_head_request_when_route_is_defined_for_get()
        {
            // Given
            var request = new FakeRequest("HEAD", "/foo/bar");
            var context = new NancyContext {
                Request = request
            };
            var resolver = CreateResolver(x => x.AddGetRoute("/bar/foo"));

            // When
            var resolvedRoute = resolver.Resolve(context);

            // Then
            resolvedRoute.ShouldNotBeNull();
            resolvedRoute.ShouldNotBeOfType <NotFoundRoute>();
            resolvedRoute.ShouldNotBeOfType <MethodNotAllowedRoute>();
        }
        public void Should_ignore_method_casing_when_resolving_routes()
        {
            // Given
            var request = new FakeRequest("GeT", "/foo/bar");
            var context = new NancyContext {
                Request = request
            };
            var resolver = CreateResolver(x => x.AddGetRoute("/foo/bar"));

            // When
            var resolvedRoute = resolver.Resolve(context);

            // Then
            resolvedRoute.ShouldNotBeNull();
            resolvedRoute.ShouldNotBeOfType <NotFoundRoute>();
            resolvedRoute.ShouldNotBeOfType <MethodNotAllowedRoute>();
        }
        public void Should_return_options_route_with_path_set_to_request_route_for_options()
        {
            // Given
            var request = new FakeRequest("OPTIONS", "/foo/bar");
            var context = new NancyContext {
                Request = request
            };
            var resolver = CreateResolver(x => x.AddGetRoute("/foo/bar"));

            // When
            var resolvedRoute = resolver.Resolve(context);

            // Then
            resolvedRoute.ShouldNotBeNull();
            resolvedRoute.Item1.ShouldBeOfType <OptionsRoute>();
            resolvedRoute.Item1.Description.Path.ShouldEqual(request.Path);
        }
Exemple #11
0
        public void Should_not_return_a_route_if_matching_and_the_filter_returns_false()
        {
            // Given
            var moduleCatalog    = new FakeModuleCatalog();
            var routeCache       = new RouteCache(moduleCatalog, new FakeModuleKeyGenerator(), A.Fake <INancyContextFactory>());
            var specificResolver = new DefaultRouteResolver(moduleCatalog, this.matcher, this.moduleBuilder);
            var request          = new FakeRequest("GET", "/filtered");
            var context          = new NancyContext {
                Request = request
            };

            // When
            var route = specificResolver.Resolve(context, routeCache).Item1;

            // Then
            route.ShouldBeOfType(typeof(NotFoundRoute));
        }
        private static async Task <bool> InvokeAsync(DateTimeOffset created, DateTimeOffset lastRun, bool debounce)
        {
            var lastRunStore = new FakeLastRunStore(lastRun);
            var middleware   = new DebounceMiddleware(lastRunStore, NullLoggerFactory.Instance);
            var meta         = debounce ? new[] { new DebounceAttribute() } : null;
            var request      = new FakeRequest(created: created, meta: meta);

            bool executed = false;

            await middleware.InvokeAsync(new Context(request), ctx =>
            {
                executed = true;
                return(Task.CompletedTask);
            });

            return(executed);
        }
        public void Should_return_a_route_if_matching_and_the_filter_returns_true()
        {
            // Given
            var moduleCatalog    = new FakeModuleCatalog();
            var routeCache       = new RouteCache(moduleCatalog, new FakeModuleKeyGenerator(), A.Fake <INancyContextFactory>(), A.Fake <IRouteSegmentExtractor>(), this.routeDescriptionProvider);
            var specificResolver = new DefaultRouteResolver(moduleCatalog, this.matcher, this.moduleBuilder, routeCache, null);
            var request          = new FakeRequest("GET", "/notfiltered");
            var context          = new NancyContext {
                Request = request
            };

            // When
            var route = specificResolver.Resolve(context).Item1;

            // Then
            route.ShouldBeOfType(typeof(Route));
        }
Exemple #14
0
        public async Task ProcessAsyncTest(string scenario, IList <RuleScenario> ruleScenarios)
        {
            var fakeRequest  = new FakeRequest();
            var fakeResponse = new FakeResponse();

            var mockRules = ruleScenarios.Select(ruleScenario =>
                                                 CreateMockRule(fakeRequest, fakeResponse, ruleScenario.RuleStatusType, ruleScenario.ContinueProcessing)).ToList();

            var rulesEngine = new RulesEngine();
            var rules       = mockRules.Select(mockRule => mockRule.Object).ToList();
            await rulesEngine.ProcessAsync(fakeRequest, fakeResponse, rules);

            for (var i = 0; i < rules.Count; i++)
            {
                VerifyMockRule(mockRules[i], fakeRequest, fakeResponse, ruleScenarios[i].ExpectedTimes);
            }
        }
Exemple #15
0
        public void Should_return_route_whos_filter_returns_true_when_there_is_also_a_matching_route_with_a_failing_filter()
        {
            // Given
            var moduleCatalog    = new FakeModuleCatalog();
            var routeCache       = new RouteCache(moduleCatalog, new FakeModuleKeyGenerator(), A.Fake <INancyContextFactory>());
            var specificResolver = new DefaultRouteResolver(moduleCatalog, this.matcher, this.moduleBuilder);
            var request          = new FakeRequest("GET", "/filt");
            var context          = new NancyContext {
                Request = request
            };

            // When
            var route = specificResolver.Resolve(context, routeCache).Item1;

            // Then
            route.Description.Condition(context).ShouldBeTrue();
        }
Exemple #16
0
        public CsrfFixture()
        {
            this.pipelines = new MockPipelines();

            this.cryptographyConfiguration = CryptographyConfiguration.Default;
            var csrfStartup = new CsrfApplicationStartup(
                this.cryptographyConfiguration,
                new DefaultCsrfTokenValidator(this.cryptographyConfiguration));

            csrfStartup.Initialize(this.pipelines);
            Csrf.Enable(this.pipelines);

            this.request = new FakeRequest("GET", "/");

            this.optionsRequest = new FakeRequest("OPTIONS", "/");

            this.response = new Response();
        }
Exemple #17
0
        public void Should_invoke_pattern_matcher_with_request_uri()
        {
            // Given
            var request = new FakeRequest("get", "/foo/bar");
            var context = new NancyContext();

            context.Request = request;
            var routeCache = new FakeRouteCache(x =>
            {
                x.AddGetRoute("/foo/bar");
            });

            // When
            this.resolver.Resolve(context, routeCache);

            // Then
            A.CallTo(() => this.matcher.Match(request.Uri, A <string> .Ignored)).MustHaveHappened();
        }
Exemple #18
0
        public void Endpoint_with_multiple_request_parameters()
        {
            //Arrange
            var    fakeEndpoint = new FakeEndpoint();
            var    fakeRequest  = new FakeRequest();
            string Param2       = "Param2";

            //Act
            var endpoint = new Endpoint(fakeEndpoint.Operation)
                           .WithRequestParameter
                           (
                fakeRequest.Name,
                fakeRequest.Type,
                fakeRequest.Format,
                fakeRequest.Required,
                fakeRequest.Description,
                fakeRequest.Loc,
                fakeRequest.Deprecated
                           )
                           .WithRequestParameter
                           (
                Param2,
                fakeRequest.Type,
                fakeRequest.Format,
                fakeRequest.Required,
                fakeRequest.Description,
                fakeRequest.Loc,
                fakeRequest.Deprecated
                           );

            //Assert
            Assert.Equal(fakeRequest.Description, endpoint.RequestParameters[0].Description);
            Assert.Null(endpoint.RequestParameters[0].Schema.Format);
            Assert.Equal(fakeRequest.Required, endpoint.RequestParameters[0].Required);
            Assert.Equal(fakeRequest.Name, endpoint.RequestParameters[0].Name);
            Assert.Equal(fakeRequest.Loc, endpoint.RequestParameters[0].In);
            Assert.Equal(fakeRequest.Type.Name.ToLowerInvariant(), endpoint.RequestParameters[0].Schema.Type);
            Assert.Equal(fakeRequest.Description, endpoint.RequestParameters[1].Description);
            Assert.Null(endpoint.RequestParameters[1].Schema.Format);
            Assert.Equal(fakeRequest.Required, endpoint.RequestParameters[1].Required);
            Assert.Equal(Param2, endpoint.RequestParameters[1].Name);
            Assert.Equal(fakeRequest.Loc, endpoint.RequestParameters[1].In);
            Assert.Equal(fakeRequest.Type.Name.ToLowerInvariant(), endpoint.RequestParameters[1].Schema.Type);
        }
        public void UrlHashKey_Keyed_by_url()
        {
            //Arrange
            var keyGen  = new UrlHashKeyGenerator();
            var request = new FakeRequest(
                method: METHOD,
                path: PATH,
                headers: acceptHeader);

            //Act
            string key = keyGen.Get(request);

            byte[] bytekey = System.Convert.FromBase64String(key);

            //Assert
            //Validating lengths from hash created.
            Assert.Equal(24, key.Length);
            Assert.Equal(16, bytekey.Length);
        }
        public void WhenTheBasicCredentialsHaveInvalidValues_ThenTheResultIsHttpBasicUnauthorizedResult()
        {
            userService.Setup(u => u.GetRegisteredUser()).Returns(new User { Salt = "saltsalt", Name = "name", Password = "******" });
            configurationManager.Setup(c => c.AppSetting("keyphrase")).Returns("key");
            var filterContext = new AuthorizationContext();
            var attr = new BasicAuthorizeAttribute();
            attr.UserService = userService.Object;
            attr.ConfigurationManager = configurationManager.Object;
            attr.RequireSsl = false;
            var request = new FakeRequest { SecureConnection = false, Local = false };
            httpContext.Setup(h => h.Request).Returns(request);
            httpContext.Setup(h => h.Response).Returns(new FakeResponse());
            httpContext.SetupProperty(h => h.User);

            request.Values["Authorization"] = "Basic: ";
            filterContext.HttpContext = httpContext.Object;
            attr.OnAuthorization(filterContext);
            filterContext.Result.Should().BeOfType<HttpBasicUnauthorizedResult>();
        }
        public void Should_set_parameters_on_resolved_route_to_parameteres_that_was_matched()
        {
            // Given
            var request = new FakeRequest("get", "/foo/bar");
            var context = new NancyContext {
                Request = request
            };

            var resolver =
                CreateResolver(x => x.AddGetRoute("/foo/bar", "module-key"));

            // When
            var resolvedRoute = resolver.Resolve(context);

            // Then
            resolvedRoute.ShouldNotBeOfType <NotFoundRoute>();
            resolvedRoute.ShouldNotBeOfType <MethodNotAllowedRoute>();
            ((string)resolvedRoute.Item2["foo"]).ShouldEqual("bar");
        }
Exemple #22
0
        public void Should_return_route_with_path_set_to_request_uri_when_single_route_could_be_resolved()
        {
            // Given
            var request = new FakeRequest("GET", "/foo/bar");
            var context = new NancyContext();

            context.Request = request;
            var routeCache = new FakeRouteCache(x =>
            {
                x.AddGetRoute("/foo/bar");
            });

            // When
            var resolvedRoute = this.resolver.Resolve(context, routeCache);

            // Then
            resolvedRoute.ShouldNotBeOfType <NotFoundRoute>();
            resolvedRoute.Item1.Description.Path.ShouldEqual(request.Uri);
        }
Exemple #23
0
        public void Should_ignore_method_casing_when_resolving_routes()
        {
            var request = new FakeRequest("GeT", "/foo/bar");
            var context = new NancyContext();

            context.Request = request;
            var routeCache = new FakeRouteCache(x =>
            {
                x.AddGetRoute("/foo/bar");
            });

            // When
            var resolvedRoute = this.resolver.Resolve(context, routeCache);

            // Then
            resolvedRoute.ShouldNotBeNull();
            resolvedRoute.ShouldNotBeOfType <NotFoundRoute>();
            resolvedRoute.ShouldNotBeOfType <MethodNotAllowedRoute>();
        }
        public void Should_set_action_on_resolved_route()
        {
            // Given
            var request = new FakeRequest("get", "/foo/bar");
            var context = new NancyContext {
                Request = request
            };

            var resolver =
                CreateResolver(x => x.AddGetRoute("/foo/bar", "module-key"));

            // When
            var resolvedRoute = resolver.Resolve(context).Item1;

            // Then
            resolvedRoute.ShouldNotBeOfType <NotFoundRoute>();
            resolvedRoute.ShouldNotBeOfType <MethodNotAllowedRoute>();
            resolvedRoute.Action.ShouldBeSameAs(this.expectedAction);
        }
Exemple #25
0
        public void Should_allow_favicon_override()
        {
            var favicon = new byte[] { 1, 2, 3 };

            bootstrapper.Favicon = favicon;
            var favIconRequest = new FakeRequest("GET", "/favicon.ico");
            var context        = new NancyContext {
                Request = favIconRequest
            };

            bootstrapper.Initialise();

            var result = bootstrapper.PreRequest.Invoke(context);

            result.ShouldNotBeNull();
            result.ContentType.ShouldEqual("image/vnd.microsoft.icon");
            result.StatusCode = HttpStatusCode.OK;
            GetBodyBytes(result).SequenceEqual(favicon).ShouldBeTrue();
        }
        public async Task Should_invoke_route_resolver_with_passed_in_accept_headers_when_path_does_not_contain_file_extensions()
        {
            // Given
            var expectedAcceptHeaders = new List <Tuple <string, decimal> >
            {
                { new Tuple <string, decimal>("application/json", 0.8m) },
                { new Tuple <string, decimal>("application/xml", 0.4m) }
            };

            var requestedAcceptHeaders =
                new List <Tuple <string, decimal> >();

            var request = new FakeRequest("GET", "/")
            {
                Headers = { Accept = expectedAcceptHeaders }
            };

            var context =
                new NancyContext {
                Request = request
            };

            var resolvedRoute = new ResolveResult(
                new FakeRoute(),
                DynamicDictionary.Empty,
                null,
                null,
                null);

            A.CallTo(() => this.routeResolver.Resolve(context))
            .Invokes(x => requestedAcceptHeaders = ((NancyContext)x.Arguments[0]).Request.Headers.Accept.ToList())
            .Returns(resolvedRoute);

            // When
            await this.requestDispatcher.Dispatch(context, new CancellationToken());

            // Then
            requestedAcceptHeaders.ShouldHaveCount(2);
            requestedAcceptHeaders[0].Item1.ShouldEqual("application/json");
            requestedAcceptHeaders[0].Item2.ShouldEqual(0.8m);
            requestedAcceptHeaders[1].Item1.ShouldEqual("application/xml");
            requestedAcceptHeaders[1].Item2.ShouldEqual(0.4m);
        }
        public void Should_return_notfoundroute_with_path_set_to_request_uri_when_route_could_not_be_resolved()
        {
            // Given
            var request = new FakeRequest("GET", "/foo/bar");
            var context = new NancyContext {
                Request = request
            };
            var resolver = CreateResolver(x => x.AddGetRoute("/bar/foo"));

            A.CallTo(() => this.matcher.Match("/foo/bar", "/bar/foo", null)).Returns(
                new FakeRoutePatternMatchResult(x => x.IsMatch(false)));

            // When
            var resolvedRoute = resolver.Resolve(context).Item1;

            // Then
            resolvedRoute.ShouldBeOfType <NotFoundRoute>();
            resolvedRoute.Description.Path.ShouldEqual(request.Path);
        }
Exemple #28
0
        public void Should_return_route_with_module_returned_by_module_builder()
        {
            // Given
            var request = new FakeRequest("GET", "/foo/bar");
            var context = new NancyContext {
                Request = request
            };
            var routeCache = new FakeRouteCache(x => x.AddGetRoute("/foo/bar"));

            var moduleReturnedByBuilder = new FakeNancyModule(x => x.AddGetRoute("/bar/foo"));

            A.CallTo(() => this.moduleBuilder.BuildModule(A <NancyModule> .Ignored, A <NancyContext> .Ignored)).Returns(
                moduleReturnedByBuilder);

            // When
            var route = this.resolver.Resolve(context, routeCache);

            // Then
            route.Item1.Description.Path.ShouldEqual("/bar/foo");
        }
        public void Default_keyed_by_query()
        {
            //Arrange
            var keyGen  = new DefaultCacheKeyGenerator(new string[] { nameof(QUERY) });
            var request = new FakeRequest(
                method: METHOD,
                path: PATH,
                headers: acceptHeader,
                body: null,
                protocol: PROTOCOL,
                query: QUERY);

            //Act
            string key = keyGen.Get(request);

            //Assert
            Assert.DoesNotContain(ACCEPT, key);
            Assert.Contains(QUERY, key);
            Assert.Contains(PATH, key);
        }
Exemple #30
0
        public void Should_allow_head_request_when_route_is_defined_for_get()
        {
            // Given
            var request = new FakeRequest("HEAD", "/foo/bar");
            var context = new NancyContext();

            context.Request = request;
            var routeCache = new FakeRouteCache(x =>
            {
                x.AddGetRoute("/foo/bar");
            });

            // When
            var resolvedRoute = this.resolver.Resolve(context, routeCache);

            // Then
            resolvedRoute.ShouldNotBeNull();
            resolvedRoute.ShouldNotBeOfType <NotFoundRoute>();
            resolvedRoute.ShouldNotBeOfType <MethodNotAllowedRoute>();
        }
        public void Should_return_user_defined_route_for_route_with_custom_options_defined()
        {
            // Given
            var request = new FakeRequest("OPTIONS", "/foo/bar");
            var context = new NancyContext {
                Request = request
            };
            var resolver = CreateResolver(x =>
            {
                x.AddGetRoute("/foo/bar");
                x.AddOptionsRoute("/foo/bar");
            });

            // When
            var route = resolver.Resolve(context).Item1;

            // Then
            route.ShouldNotBeNull();
            route.ShouldNotBeOfType <OptionsRoute>();
        }
        public void Default_keyed_by_url_only_with_removal_key()
        {
            //Arrange
            var keyGen  = new DefaultCacheKeyGenerator();
            var request = new FakeRequest(
                method: METHOD,
                path: PATH,
                headers: acceptHeader,
                body: null,
                protocol: PROTOCOL,
                query: string.Concat(QUERY, "?RapidCacheRemove=true"));

            //Act
            string key = keyGen.Get(request);

            //Assert
            Assert.DoesNotContain(ACCEPT, key);
            Assert.DoesNotContain(QUERY, key);
            Assert.Contains(PATH, key);
        }
Exemple #33
0
        private static KendoGridRequest SetupBinder(NameValueCollection form, NameValueCollection queryString)
        {
            var fakeRequest = new FakeRequest("POST", form, queryString ?? new NameValueCollection());
            var httpContext = new FakeContext(fakeRequest);

            var controller          = new FakeController();
            var controllerContext   = new ControllerContext(new RequestContext(httpContext, new RouteData()), controller);
            var modelBindingContext = new ModelBindingContext();

            var binder = new KendoGridModelBinder();
            var model  = binder.BindModel(controllerContext, modelBindingContext);

            Assert.IsNotNull(model);

            var gridRequest = model as KendoGridRequest;

            Assert.IsNotNull(gridRequest);

            return(gridRequest);
        }
Exemple #34
0
        public void Should_return_methodnotallowedroute_with_allow_header_set_to_allowed_methods_matching_request_route()
        {
            // Given
            var request = new FakeRequest("POST", "/foo/bar");
            var context = new NancyContext();

            context.Request = request;
            var routeCache = new FakeRouteCache(x =>
            {
                x.AddGetRoute("/foo/bar");
                x.AddPutRoute("/foo/bar");
            });

            // When
            var route = this.resolver.Resolve(context, routeCache).Item1;

            // Then
            route.ShouldNotBeNull();
            route.ShouldBeOfType <MethodNotAllowedRoute>();
            route.Invoke(new DynamicDictionary()).Headers["Allow"].ShouldEqual("GET, PUT");
        }
        public void Should_return_optionsroute_with_allow_header_set_to_allowed_methods_matching_request_route_for_options()
        {
            // Given
            var request = new FakeRequest("OPTIONS", "/foo/bar");
            var context = new NancyContext {
                Request = request
            };
            var resolver = CreateResolver(x =>
            {
                x.AddGetRoute("/foo/bar");
                x.AddPutRoute("/foo/bar");
            });

            // When
            var route = resolver.Resolve(context).Item1;

            // Then
            route.ShouldNotBeNull();
            route.ShouldBeOfType <OptionsRoute>();
            route.Invoke(new DynamicDictionary()).Headers["Allow"].ShouldEqual("GET, PUT");
        }
Exemple #36
0
        public void Should_invoke_pattern_matcher_for_all_entries_in_route_cache()
        {
            // Given
            var request = new FakeRequest("get", "/foo/bar");
            var context = new NancyContext();

            context.Request = request;
            var routeCache = new FakeRouteCache(x =>
            {
                x.AddGetRoute("/foo/bar");
                x.AddGetRoute("/bar/foo");
                x.AddGetRoute("/foobar");
            });

            // When
            this.resolver.Resolve(context, routeCache);

            // Then
            A.CallTo(() => this.matcher.Match(A <string> .Ignored, "/foo/bar")).MustHaveHappened();
            A.CallTo(() => this.matcher.Match(A <string> .Ignored, "/bar/foo")).MustHaveHappened();
            A.CallTo(() => this.matcher.Match(A <string> .Ignored, "/foobar")).MustHaveHappened();
        }
        public void WhenThereIsNoAuthorizationHeader_ThenTheResultIsHttpBasicUnauthorizedResult()
        {
            var filterContext = new AuthorizationContext();
            var attr = new BasicAuthorizeAttribute();
            attr.RequireSsl = false;
            var request = new FakeRequest { SecureConnection = false, Local = false };
            httpContext.Setup(h => h.Request).Returns(request);

            filterContext.HttpContext = httpContext.Object;
            attr.OnAuthorization(filterContext);
            filterContext.Result.Should().BeOfType<HttpBasicUnauthorizedResult>();
        }
        public void Should_invoke_route_resolver_with_passed_in_accept_headers_when_path_does_not_contain_file_extensions()
        {
            // Given
            var expectedAcceptHeaders = new List<Tuple<string, decimal>>
            {
                { new Tuple<string, decimal>("application/json", 0.8m) },
                { new Tuple<string, decimal>("application/xml", 0.4m) }
            };

            var requestedAcceptHeaders =
                new List<Tuple<string, decimal>>();

            var request = new FakeRequest("GET", "/")
            {
                Headers = { Accept = expectedAcceptHeaders }
            };

            var context =
                new NancyContext { Request = request };

            var resolvedRoute = new ResolveResult(
               new FakeRoute(),
               DynamicDictionary.Empty,
               null,
               null,
               null);

            A.CallTo(() => this.routeResolver.Resolve(context))
                .Invokes(x => requestedAcceptHeaders = ((NancyContext)x.Arguments[0]).Request.Headers.Accept.ToList())
                .Returns(resolvedRoute);

            // When
            this.requestDispatcher.Dispatch(context);

            // Then
            requestedAcceptHeaders.ShouldHaveCount(2);
            requestedAcceptHeaders[0].Item1.ShouldEqual("application/json");
            requestedAcceptHeaders[0].Item2.ShouldEqual(0.8m);
            requestedAcceptHeaders[1].Item1.ShouldEqual("application/xml");
            requestedAcceptHeaders[1].Item2.ShouldEqual(0.4m);
        }
        public void WhenThereIsAPrinciple_ThenTheUserIsStoredInTheContext()
        {
            userService.Setup(u => u.GetRegisteredUser()).Returns(new User { Salt = "saltsalt", Name = "name", Password = "******" });
            configurationManager.Setup(c => c.AppSetting("keyphrase")).Returns("key");
            var filterContext = new AuthorizationContext();
            var attr = new BasicAuthorizeAttribute();
            attr.UserService = userService.Object;
            attr.ConfigurationManager = configurationManager.Object;
            attr.RequireSsl = false;
            var request = new FakeRequest { SecureConnection = false, Local = false };
            httpContext.Setup(h => h.Request).Returns(request);
            httpContext.Setup(h => h.Response).Returns(new FakeResponse());
            httpContext.SetupProperty(h => h.User);

            request.Values["Authorization"] = "Basic: " + ToBase64("name", "password");
            filterContext.HttpContext = httpContext.Object;
            attr.OnAuthorization(filterContext);
            filterContext.HttpContext.User.Should().BeOfType<GenericPrincipal>();
        }