C# FubuRegistry.ToRuntime方法代码示例

        public void Start()
        {
            _controller = _input.BuildRemoteController();
            var context = new StorytellerContext(_controller, _input);

            if (_controller.BinPath.IsEmpty())
            {
                throw new Exception("Could not determine any BinPath for the testing AppDomain. Has the Storyteller specification project been compiled, \nor is Storyteller using the wrong compilation target maybe?\n\ntype 'st.exe ? open' or st.exe ? run' to see the command usages\n\n");
            }

            context.Start();

            var registry = new FubuRegistry();


            registry.AlterSettings<DiagnosticsSettings>(_ => _.TraceLevel = TraceLevel.Verbose);
            registry.Mode = "development";
            registry.HostWith<NOWIN>();
            registry.Services.For<IRemoteController>().Use(_controller);
            registry.Services.For<StorytellerContext>().Use(context);
            
            registry.Services.IncludeRegistry<WebApplicationRegistry>();


            _server = registry.ToRuntime();
        }

        public void see_tracing_logs_in_verbose_mode_happy_path()
        {
            var registry = new FubuRegistry();
            registry.ServiceBus.Enable(true);
            registry.Features.Diagnostics.Enable(TraceLevel.Verbose);
            registry.ServiceBus.EnableInMemoryTransport();
            registry.AlterSettings<LightningQueueSettings>(x => x.DisableIfNoChannels = true);

            using (var runtime = registry.ToRuntime())
            {
                var bus = runtime.Get<IServiceBus>();

                bus.Consume(new TracedInput());

                var history = runtime.Get<IChainExecutionHistory>();

                var log = history.RecentReports().Single(x => x.RootChain != null && x.RootChain.InputType() == typeof(TracedInput));

                log.Request["headers"].ShouldBeOfType<Dictionary<string, string>>();
                
                log.Steps.Any().ShouldBeTrue();
                log.Steps.Any(x => x.Log is StringMessage).ShouldBeTrue();

                log.Steps.Each(x => Debug.WriteLine(x));
            }
        }

        public void can_inject_the_right_html_on_GET_for_html_text()
        {
            var registry = new FubuRegistry();
            registry.AlterSettings<OwinSettings>(x =>
            {
                x.AddMiddleware<HtmlHeadInjectionMiddleware>().Arguments.With(new InjectionOptions
                {
                    Content = e => new HtmlTag("script").Attr("foo", "bar").ToString()
                });
            });

            using (var server = registry.ToRuntime())
            {
                server.Scenario(_ =>
                {
                    _.Get.Action<SimpleHtmlEndpoint>(x => x.get_html_content());

                    _.ContentShouldContain("<script foo=\"bar\"></script></head>");
                });

                server.Scenario(_ =>
                {
                    _.Get.Action<SimpleHtmlEndpoint>(x => x.get_text_content());

                    _.ContentShouldNotContain("<script foo=\"bar\"></script></head>");
                });
            }
        }

        public void is_registered()
        {
            var registry = new FubuRegistry();
            registry.AlterSettings<CommonViewNamespaces>(x =>
            {
                x.Add("Foo");
                x.Add("Bar");
            });

            using (var runtime = registry.ToRuntime())
            {
                var container = runtime.Get<IContainer>();

                var useNamespaces = container.GetInstance<CommonViewNamespaces>();

                useNamespaces.Namespaces.ShouldContain(typeof (VirtualPathUtility).Namespace);
                useNamespaces.Namespaces.ShouldContain(typeof (string).Namespace);
                useNamespaces.Namespaces.ShouldContain(typeof (FileSet).Namespace);
                useNamespaces.Namespaces.ShouldContain(typeof (ParallelQuery).Namespace);
                useNamespaces.Namespaces.ShouldContain(typeof (HtmlTag).Namespace);
                useNamespaces.Namespaces.ShouldContain("FubuMVC.Tests.Http.Hosting");
                useNamespaces.Namespaces.ShouldContain("Foo");
                useNamespaces.Namespaces.ShouldContain("Bar");
            }
        }

        public void can_set_the_node_name_programmatically()
        {
            var registry = new FubuRegistry {NodeName = "MyNode"};

            using (var fubuRuntime = registry.ToRuntime())
            {
                fubuRuntime.Get<ChannelGraph>().Name.ShouldBe("MyNode");
            }
        }

        public void register_a_non_default_culture_info()
        {
            var registry = new FubuRegistry();
            registry.Features.Localization.Enable(true);
            registry.Features.Localization.Configure(x => { x.DefaultCulture = new CultureInfo("en-CA"); });

            using (var runtime = registry.ToRuntime())
            {
                runtime.Get<CultureInfo>().Name.ShouldBe("en-CA");
            }
        }

        public void SetUp()
        {
            var registry = new FubuRegistry(x =>
            {
                x.Actions.IncludeType<AsyncAction>();
                x.Policies.Local.Add<EarlyReturnConvention>();
                x.HostWith<Katana>();
            });

            _server = registry.ToRuntime();
        }

        public void AuthenticationSetup()
        {
            var registry = new FubuRegistry();
            configure(registry);

            registry.Features.Authentication.Enable(true);

            server = registry.ToRuntime();
            theContainer = server.Get<IContainer>();

            beforeEach();
        }

 public void should_start_when_transport_disabled()
 {
     var registry = new FubuRegistry();
     registry.AlterSettings<TransportSettings>(x =>
     {
         x.Enabled = true;
         x.InMemoryTransport = InMemoryTransportMode.Enabled;
     });
     registry.AlterSettings<LightningQueueSettings>(x => x.DisableIfNoChannels = true);
     using (var application = registry.ToRuntime())
     {
     }
 }

        public void can_happily_plug_in_an_alternative_route_policy()
        {
            FakeRoutePolicy.IWasCalled = false;

            var registry = new FubuRegistry();
            registry.RoutePolicy<FakeRoutePolicy>();

            using (var runtime = registry.ToRuntime())
            {
            }

            FakeRoutePolicy.IWasCalled.ShouldBeTrue();
        }

        public void end_to_end()
        {
            var registry = new FubuRegistry();
            registry.Features.ServerSentEvents.Enable(true);

            using (var runtime = registry.ToRuntime())
            {
                var chain = runtime.Behaviors.ChainFor<ChannelWriter<FakeTopic>>(x => x.Write(null));
                var container = runtime.Get<IContainer>();
                container.GetInstance<IChannelInitializer<FakeTopic>>()
                    .ShouldBeOfType<DefaultChannelInitializer<FakeTopic>>();

                container.GetInstance<IActionBehavior>(chain.UniqueId.ToString());
            }
        }

        public void the_order_of_the_configuration_action_was_wrong()
        {
            var registry = new FubuRegistry();
            registry.Actions.IncludeType<TestEndpoint>();
            registry.Features.AntiForgery.Enable(true);

            using (var runtime = registry.ToRuntime())
            {
                var graph = runtime.Get<BehaviorGraph>();

                graph.ChainFor<TestEndpoint>(x => x.post_csrf(null))
                    .OfType<AntiForgeryNode>().Any()
                    .ShouldBeTrue();
            }
        }

        public void register_services()
        {
            var registry = new FubuRegistry();
            registry.Features.ServerSentEvents.Enable(true);

            using (var runtime = registry.ToRuntime())
            {
                var container = runtime.Get<IContainer>();

                container.DefaultRegistrationIs<IEventPublisher, EventPublisher>();
                container.DefaultRegistrationIs<IServerEventWriter, ServerEventWriter>();
                container.DefaultRegistrationIs(typeof (IEventQueueFactory<>), typeof (DefaultEventQueueFactory<>));

                container.DefaultSingletonIs<ITopicChannelCache, TopicChannelCache>();
            }
        }

        public void can_register_custom_binding_services()
        {
            var registry = new FubuRegistry();
            registry.Models
                .BindModelsWith<ExampleModelBinder>()
                .BindPropertiesWith<ExamplePropertyBinder>()
                .ConvertUsing<ExampleConverter>();

            using (var runtime = registry.ToRuntime())
            {
                var container = runtime.Get<IContainer>();
                container.ShouldHaveRegistration<IConverterFamily, ExampleConverter>();
                container.ShouldHaveRegistration<IPropertyBinder, ExamplePropertyBinder>();
                container.ShouldHaveRegistration<IModelBinder, ExampleModelBinder>();
            }
        }

        public void should_place_composite_error_handler()
        {
            var registry = new FubuRegistry();
            registry.ServiceBus.Enable(true);
            registry.Handlers.Include<MyConsumer>();
            registry.ServiceBus.EnableInMemoryTransport();

            registry.Policies.Global.Add<RespondThenMoveToErrorsPolicy>();

            using (var runtime = registry.ToRuntime())
            {
                runtime.Behaviors.Handlers.Each(x =>
                {
                    x.ErrorHandlers.Count.ShouldBe(1);
                });
            }
        }