public void matches_negative_because_of_methods()
        {
            var filter = new HttpMethodFilter("POST");
            var chain = new RoutedChain(new RouteDefinition("something"));
            chain.Route.AddHttpMethodConstraint("GET");

            filter.Matches(chain).ShouldBeFalse();
        }
 public void SetUp()
 {
     theChain = new BehaviorChain();
     theRoutedChain = new RoutedChain("something");
     theUrls = new StubUrlRegistry();
     _report = new Lazy<EndpointReport>(() => EndpointReport.ForChain(theChain));
     _routedReport = new Lazy<EndpointReport>(() => EndpointReport.ForChain(theRoutedChain));
 }
        public void matches_positive()
        {
            var filter = new HttpMethodFilter("POST");
            var chain = new RoutedChain(new RouteDefinition("something"));
            chain.Route.AddHttpMethodConstraint("POST");

            filter.Matches(chain).ShouldBeTrue();
        }
        public void automatically_excludes_the_NotAuthenticated_attribute()
        {
            var chain = new RoutedChain("foo");
            chain.AddToEnd(ActionCall.For<AuthenticatedEndpoints>(x => x.get_notauthenticated()));

            new AuthenticationSettings().ShouldBeExcluded(chain)
                .ShouldBeTrue();
        }
        private IEnumerable<ChainRoute> toRoutes(RoutedChain chain)
        {
            yield return new ChainRoute {Chain = chain, Route = chain.Route};

            foreach (var additionalRoute in chain.AdditionalRoutes)
            {
                yield return new ChainRoute {Chain = chain, Route = additionalRoute};
            }
        }
        public IEnumerable<RouteBase> BuildRoute(IServiceFactory factory, SessionStateRequirement defaultSessionRequirement, RoutedChain chain)
        {
            yield return buildRoute(factory, defaultSessionRequirement, chain, chain.Route);

            foreach (var alias in chain.AdditionalRoutes)
            {
                yield return buildRoute(factory, defaultSessionRequirement, chain, alias);
            }
        }
        public IEnumerable<RouteParameter> ToParameters(RoutedChain chain)
        {
            if (chain.Route.Input == null)
            {
                return Enumerable.Empty<RouteParameter>();
            }

            return chain.Route.Input.RouteParameters;
        }
Exemple #8
0
        /// <summary>
        ///   Creates a new BehaviorChain for an action method
        /// </summary>
        /// <typeparam name = "T"></typeparam>
        /// <param name = "expression"></param>
        /// <returns></returns>
        public static RoutedChain For <T>(Expression <Action <T> > expression, string url)
        {
            var call  = ActionCall.For(expression);
            var chain = new RoutedChain(new RouteDefinition(url), call.InputType(), call.ResourceType());

            chain.AddToEnd(call);

            return(chain);
        }
        public bool ShouldBeExcluded(RoutedChain chain)
        {
            if (chain.Calls.Any(x => x.HasAttribute<NotAuthenticatedAttribute>())) return true;
            if (chain.Calls.Any(x => x.HasAttribute<PassThroughAuthenticationAttribute>())) return true;

            if (ExcludeDiagnostics && chain is DiagnosticChain) return true;

            return _exclusions(chain);
        }
        public void SetUp()
        {
            var graph = BehaviorGraph.BuildFrom(x =>
            {
                x.Actions.IncludeType<MethodAction>();
            });

            theChain = graph.BehaviorFor<MethodAction>(x => x.Get_cases_from_Start_to_End(null))
                .As<RoutedChain>();
        }
        public void hash_values_when_the_chain_has_a_route_but_not_real_values()
        {
            var chain = new RoutedChain(new RouteDefinition("some/pattern/url"));

            var currentChain = new CurrentChain(chain, new Dictionary<string, object>());

            var varyBy = new VaryByResource(currentChain);

            var values = varyBy.Values();
            values.Select(x => "{0}={1}".ToFormat(x.Key, x.Value)).ShouldHaveTheSameElementsAs("chain=" + chain.GetRoutePattern());
        }
        public void got_to_have_a_route_name()
        {
            var chain = new RoutedChain("foo");
            //chain.RouteName = "bar";
            chain.Route.AddHttpMethodConstraint("PUT");

            var router = new MyJavascriptRouter();
            Exception<ArgumentOutOfRangeException>.ShouldBeThrownBy(() => {
                router.Add(chain);
            });
        }
        public void hash_values_with_a_route_That_has_substitutions()
        {
            var chain = new RoutedChain(RouteBuilder.Build<Query>("some/pattern/url/{from}/{to}"));

            var currentChain = new CurrentChain(chain, new Dictionary<string, object>{{"from", 1}, {"to", 2}});
            var varyBy = new VaryByResource(currentChain);

            var values = varyBy.Values();
            values.Select(x => "{0}={1}".ToFormat(x.Key, x.Value))
                .ShouldHaveTheSameElementsAs("chain=" + "some/pattern/url/{from}/{to}", "from=1", "to=2");
        }
        public void apply_a_custome_exclusion_and_it_does_not_apply_to_login_page()
        {
            var settings = new AuthenticationSettings();
            var chain = new RoutedChain("foo");
            chain.AddToEnd(ActionCall.For<LoginController>(x => x.get_login(null)));
            settings.ShouldBeExcluded(chain).ShouldBeTrue();

            settings.ExcludeChains = c => c.Calls.Count() == 5; // just need a fake

            settings.ShouldBeExcluded(chain).ShouldBeTrue();
        }
        public void apply_a_custom_exclusion()
        {
            var chain = new RoutedChain("foo");
            chain.AddToEnd(ActionCall.For<AuthenticatedEndpoints>(x => x.get_tag()));

            var settings = new AuthenticationSettings();

            settings.ShouldBeExcluded(chain).ShouldBeFalse();

            settings.ExcludeChains = c => typeof (HtmlTag) == c.ResourceType();

            settings.ShouldBeExcluded(chain).ShouldBeTrue();
        }
        public void find_by_category_when_the_category_is_null_and_relaxed_search_and_only_one_chain_2()
        {
            var search = new ChainSearch
            {
                CategoryMode = CategorySearchMode.Relaxed,
                CategoryOrHttpMethod = null
            };

            var chain1 = new RoutedChain("something");
            chain1.UrlCategory.Category = Categories.DEFAULT;

            var chains = new BehaviorChain[] { chain1, };

            search.FindForCategory(chains).Single().ShouldBeTheSameAs(chains.Single());
        }
        public void add_route_happy_path()
        {
            var chain = new RoutedChain("foo");
            chain.RouteName = "bar";
            chain.Route.AddHttpMethodConstraint("PUT");

            var router = new MyJavascriptRouter();
            router.Add(chain);

            var route = router.Routes().Single();

            route.Name.ShouldBe("bar");
            route.Method.ShouldBe("PUT");
            route.Finder(null).ShouldBeTheSameAs(chain);
        }
        public void sets_the_full_url()
        {
            var fullUrl = "this/is/a/test";

            var route = new RouteDefinition("blah");
            route.ApplyInputType(typeof(object));

            theChain = new RoutedChain(fullUrl);

            theUrlResolver.Stub(x => x.UrlFor(theInput, theChain)).Return(fullUrl);
            theResolver.Stub(x => x.Find(theSearch)).Return(theChain);

            theRequest.Attach(theServices);

            theRequest.Url.ShouldEqual(fullUrl);
        }
        public void SetUp()
        {
            theServices = new InMemoryServiceLocator();
            theSearch = ChainSearch.ByUniqueInputType(typeof (object));
            theInput = new object();

            theResolver = MockRepository.GenerateStub<IChainResolver>();
            theUrlResolver = MockRepository.GenerateStub<IChainUrlResolver>();

            theChain = new RoutedChain("something");

            theServices.Add(theResolver);
            theServices.Add(theUrlResolver);

            theRequest = new FormRequest(theSearch, theInput);
        }
        public void adds_the_authentication_node_if_it_exists()
        {
            var registry = new FubuRegistry();
            registry.Actions.IncludeType<AuthenticatedEndpoint>();
            registry.Configure(
                graph => { graph.Chains.OfType<RoutedChain>().Each(x => x.Authentication = new AuthNode()); });

            using (var runtime = registry.ToRuntime())
            {
                runtime.Behaviors.ChainFor<AuthenticatedEndpoint>(x => x.get_hello())
                    .First().ShouldBeOfType<AuthNode>();
            }

            var chain = new RoutedChain("something");
            var auth = new AuthNode();
            chain.Authentication = auth;
        }
        public void find_by_category_relaxed_with_only_one_chain()
        {
            var search = new ChainSearch
            {
                CategoryMode = CategorySearchMode.Relaxed,
                CategoryOrHttpMethod = "something"
            };

            var chain3 = new RoutedChain("")
            {
                UrlCategory =
                {
                    Category = null
                }
            };

            var chains = new BehaviorChain[] { chain3 };

            search.FindForCategory(chains).ShouldHaveTheSameElementsAs(chain3);
        }
        public void do_nothing_if_tracing_is_off()
        {
            var registry = new FubuRegistry();
            registry.Features.Diagnostics.Enable(TraceLevel.None);
            registry.Configure(graph =>
            {
                chain1 = new RoutedChain("something");
                chain1.AddToEnd(Wrapper.For<SimpleBehavior>());
                chain1.AddToEnd(Wrapper.For<DifferentBehavior>());
                graph.AddChain(chain1);

                chain2 = new BehaviorChain();
                chain2.IsPartialOnly = true;
                chain2.AddToEnd(Wrapper.For<SimpleBehavior>());
                chain2.AddToEnd(Wrapper.For<DifferentBehavior>());
                graph.AddChain(chain2);
            });

            var notTracedGraph = BehaviorGraph.BuildFrom(registry);
            notTracedGraph.Chains.SelectMany(x => x).Any(x => x is BehaviorTracerNode).ShouldBeFalse();
        }
        public void SetUp()
        {
            var registry = new FubuRegistry();
            registry.Configure(graph =>
            {
                chain1 = new RoutedChain("something");
                chain1.AddToEnd(Wrapper.For<SimpleBehavior>());
                chain1.AddToEnd(Wrapper.For<DifferentBehavior>());
                graph.AddChain(chain1);

                chain2 = new BehaviorChain();
                chain2.IsPartialOnly = true;
                chain2.AddToEnd(Wrapper.For<SimpleBehavior>());
                chain2.AddToEnd(Wrapper.For<DifferentBehavior>());
                graph.AddChain(chain2);
            });

            registry.Features.Diagnostics.Enable(TraceLevel.Verbose);

            BehaviorGraph.BuildFrom(registry);
        }
        public void behavior_tracers_deeper()
        {
            var node = Wrapper.For<SimpleBehavior>();
            var chain = new RoutedChain("foo");
            chain.AddToEnd(node);
            node.AddAfter(Wrapper.For<DifferentBehavior>());

            ApplyTracing.ApplyToChain(chain);

            var objectDef = chain.As<IContainerModel>().ToObjectDef().FindDependencyDefinitionFor<IActionBehavior>();

            objectDef.Type.ShouldEqual(typeof(BehaviorTracer));
            var child1 = objectDef.FindDependencyDefinitionFor<IActionBehavior>();
            child1.Type.ShouldEqual(typeof(SimpleBehavior));

            var child2 = child1.FindDependencyDefinitionFor<IActionBehavior>();
            child2.Type.ShouldEqual(typeof(BehaviorTracer));

            var child3 = child2.FindDependencyDefinitionFor<IActionBehavior>();
            child3.Type.ShouldEqual(typeof(DifferentBehavior));
        }
        public void find_by_category_strict_with_multiple_chains_1()
        {
            var search = new ChainSearch
            {
                CategoryMode = CategorySearchMode.Strict,
                CategoryOrHttpMethod = "something"
            };

            var chain1 = new RoutedChain("")
            {
                UrlCategory =
                {
                    Category = "something"
                }
            };

            var chain2 = new RoutedChain("")
            {
                UrlCategory =
                {
                    Category = Categories.DEFAULT
                }
            };

            var chain3 = new RoutedChain("")
            {
                UrlCategory =
                {
                    Category = null
                }
            };

            var chains = new BehaviorChain[] { chain1, chain2, chain3 };

            search.FindForCategory(chains).ShouldHaveTheSameElementsAs(chain1);
        }
 public IEnumerable<RouteParameter> ToParameters(RoutedChain chain)
 {
     return new RouteParameter[0];
 }
        public void find_by_category_strict_with_multiple_chains_2()
        {
            var search = new ChainSearch
            {
                CategoryMode = CategorySearchMode.Strict,
                CategoryOrHttpMethod = "something"
            };

            var chain1 = new RoutedChain("")
            {
                UrlCategory =
                {
                    Category = "different"
                }
            };

            var chain2 = new RoutedChain("")
            {
                UrlCategory =
                {
                    Category = Categories.DEFAULT
                }
            };

            var chain3 = new RoutedChain("")
            {
                UrlCategory =
                {
                    Category = "else"
                }
            };

            var chains = new BehaviorChain[] { chain1, chain2, chain3 };

            search.FindForCategory(chains).Any().ShouldBeFalse();
        }
        public void find_by_null_category_with_multiple_chains_but_only_one_is_default_3()
        {
            var search = new ChainSearch
            {
                CategoryMode = CategorySearchMode.Relaxed,
                CategoryOrHttpMethod = null
            };

            var chain1 = new RoutedChain("")
            {
                UrlCategory =
                {
                    Category = "something"
                }
            };

            var chain2 = new RoutedChain("")
            {
                UrlCategory =
                {
                    Category = Categories.DEFAULT
                }
            };

            var chain3 = new RoutedChain("")
            {
                UrlCategory =
                {
                    Category = Categories.DEFAULT
                }
            };

            var chains = new BehaviorChain[] { chain1, chain2, chain3 };

            search.FindForCategory(chains).ShouldHaveTheSameElementsAs(chain2, chain3);
        }
 public string ToUrl(RoutedChain chain)
 {
     return ("/fake/" + chain.GetRoutePattern()).Replace("//", "/");
 }
Exemple #30
0
        private BehaviorChain buildChainForView(IViewToken view)
        {
            BehaviorChain chain = null;

            if (view.ViewModel.HasAttribute<UrlPatternAttribute>())
            {
                var route = view.ViewModel.GetAttribute<UrlPatternAttribute>().BuildRoute(view.ViewModel);
                chain = new RoutedChain(route, view.ViewModel, view.ViewModel);
            }
            else
            {
                chain = BehaviorChain.ForResource(view.ViewModel);
            }

            chain.Tags.Add("ActionlessView");
            chain.UrlCategory.Category = Categories.VIEW;
            return chain;
        }
        public void find_by_null_category_with_multiple_chains_but_only_one_is_default()
        {
            var search = new ChainSearch
            {
                CategoryMode = CategorySearchMode.Relaxed,
                CategoryOrHttpMethod = null
            };

            var chain1 = new RoutedChain(""){
                UrlCategory ={
                    Category = null
                }
            };

            var chain2 = new RoutedChain("")
            {
                UrlCategory =
                {
                    Category = Categories.DEFAULT
                }
            };

            var chains = new BehaviorChain[] { chain1, chain2};

            search.FindForCategory(chains).Single().ShouldBeTheSameAs(chain2);
        }