public void CanLoadConfigFromString(string configString) { //const string configString = ; var runtimeConfig = new RuntimeConfiguration(); runtimeConfig.LoadConfiguration(ConfigurationSectionHandler.CreateFromXml(configString)); }
public static void UpdateConfigFromFile(RuntimeConfiguration runtimeConfiguration, string configFile) { using (TextReader file = new StreamReader(configFile)) { UpdateConfigFromFileContent(runtimeConfiguration, file.ReadToEnd()); } }
public static RuntimeConfiguration GetConfig() { var configuration = new RuntimeConfiguration(); configuration.UpdateFromQueryString(); return(configuration); }
public static RuntimeConfiguration LoadFromConfigFile(ConfigurationSectionHandler configSection) { if (configSection == null) { throw new ArgumentNullException("configSection"); } var config = new RuntimeConfiguration(); if (configSection.Language != null) { config.ToolLanguage = string.IsNullOrEmpty(configSection.Language.Tool) ? CultureInfo.GetCultureInfo(configSection.Language.Feature) : CultureInfo.GetCultureInfo(configSection.Language.Tool); } if (configSection.BindingCulture.ElementInformation.IsPresent) { config.BindingCulture = CultureInfo.GetCultureInfo(configSection.BindingCulture.Name); } if (configSection.UnitTestProvider != null) { config.SetUnitTestDefaultsByName(configSection.UnitTestProvider.Name); if (!string.IsNullOrEmpty(configSection.UnitTestProvider.RuntimeProvider)) { config.RuntimeUnitTestProviderType = GetTypeConfig(configSection.UnitTestProvider.RuntimeProvider); } //TODO: config.CheckUnitTestConfig(); } if (configSection.Runtime != null) { config.DetectAmbiguousMatches = configSection.Runtime.DetectAmbiguousMatches; config.StopAtFirstError = configSection.Runtime.StopAtFirstError; config.MissingOrPendingStepsOutcome = configSection.Runtime.MissingOrPendingStepsOutcome; } if (configSection.Trace != null) { if (!string.IsNullOrEmpty(configSection.Trace.Listener)) { config.TraceListenerType = GetTypeConfig(configSection.Trace.Listener); } config.TraceSuccessfulSteps = configSection.Trace.TraceSuccessfulSteps; config.TraceTimings = configSection.Trace.TraceTimings; config.MinTracedDuration = configSection.Trace.MinTracedDuration; } foreach (var element in configSection.StepAssemblies) { Assembly stepAssembly = Assembly.Load(((StepAssemblyConfigElement)element).Assembly); config._additionalStepAssemblies.Add(stepAssembly); } return(config); }
public void Setup() { skeletonProviders = new Dictionary<ProgrammingLanguage, IStepDefinitionSkeletonProvider>(); skeletonProviders.Add(ProgrammingLanguage.CSharp, new Mock<IStepDefinitionSkeletonProvider>().Object); var culture = new CultureInfo("en-US"); contextManagerStub = new Mock<IContextManager>(); scenarioContext = new ScenarioContext(new ScenarioInfo("scenario_title"), null, null); contextManagerStub.Setup(cm => cm.ScenarioContext).Returns(scenarioContext); contextManagerStub.Setup(cm => cm.FeatureContext).Returns(new FeatureContext(new FeatureInfo(culture, "feature_title", "", ProgrammingLanguage.CSharp), culture)); runtimeBindingRegistryBuilderStub = new Mock<IRuntimeBindingRegistryBuilder>(); bindingRegistryStub = new Mock<IBindingRegistry>(); bindingRegistryStub.Setup(br => br.GetHooks(HookType.BeforeStep)).Returns(beforeStepEvents); bindingRegistryStub.Setup(br => br.GetHooks(HookType.AfterStep)).Returns(afterStepEvents); bindingRegistryStub.Setup(br => br.GetHooks(HookType.BeforeScenarioBlock)).Returns(beforeScenarioBlockEvents); bindingRegistryStub.Setup(br => br.GetHooks(HookType.AfterScenarioBlock)).Returns(afterScenarioBlockEvents); runtimeConfiguration = new RuntimeConfiguration(); errorProviderStub = new Mock<IErrorProvider>(); testTracerStub = new Mock<ITestTracer>(); stepDefinitionMatcherStub = new Mock<IStepDefinitionMatchService>(); methodBindingInvokerMock = new Mock<IBindingInvoker>(); stepErrorHandlers = new Dictionary<string, IStepErrorHandler>(); }
public TestTracer(ITraceListener traceListener, IStepFormatter stepFormatter, IStepDefinitionSkeletonProvider stepDefinitionSkeletonProvider, RuntimeConfiguration runtimeConfiguration) { this.traceListener = traceListener; this.stepFormatter = stepFormatter; this.stepDefinitionSkeletonProvider = stepDefinitionSkeletonProvider; this.runtimeConfiguration = runtimeConfiguration; }
public TestRunnerManager(IObjectContainer globalContainer, IContainerBuilder containerBuilder, RuntimeConfiguration runtimeConfiguration, IRuntimeBindingRegistryBuilder bindingRegistryBuilder) { this.globalContainer = globalContainer; this.containerBuilder = containerBuilder; this.runtimeConfiguration = runtimeConfiguration; this.bindingRegistryBuilder = bindingRegistryBuilder; }
protected MethodBinding(RuntimeConfiguration runtimeConfiguration, IErrorProvider errorProvider, MethodInfo method) { this.runtimeConfiguration = runtimeConfiguration; this.errorProvider = errorProvider; BindingAction = CreateMethodDelegate(method); MethodInfo = method; ParameterTypes = method.GetParameters().Select(pi => pi.ParameterType).ToArray(); ReturnType = method.ReturnType; }
public static RuntimeConfiguration LoadFromConfigFile(ConfigurationSectionHandler configSection) { if (configSection == null) throw new ArgumentNullException("configSection"); var config = new RuntimeConfiguration(); if (configSection.Language != null) { config.ToolLanguage = string.IsNullOrEmpty(configSection.Language.Tool) ? CultureInfo.GetCultureInfo(configSection.Language.Feature) : CultureInfo.GetCultureInfo(configSection.Language.Tool); } if (configSection.BindingCulture.ElementInformation.IsPresent) { config.BindingCulture = CultureInfo.GetCultureInfo(configSection.BindingCulture.Name); } if (configSection.UnitTestProvider != null) { config.SetUnitTestDefaultsByName(configSection.UnitTestProvider.Name); if (!string.IsNullOrEmpty(configSection.UnitTestProvider.RuntimeProvider)) config.RuntimeUnitTestProviderType = GetTypeConfig(configSection.UnitTestProvider.RuntimeProvider); //TODO: config.CheckUnitTestConfig(); } if (configSection.Runtime != null) { config.DetectAmbiguousMatches = configSection.Runtime.DetectAmbiguousMatches; config.StopAtFirstError = configSection.Runtime.StopAtFirstError; config.MissingOrPendingStepsOutcome = configSection.Runtime.MissingOrPendingStepsOutcome; } if (configSection.Trace != null) { if (!string.IsNullOrEmpty(configSection.Trace.Listener)) config.TraceListenerType = GetTypeConfig(configSection.Trace.Listener); config.TraceSuccessfulSteps = configSection.Trace.TraceSuccessfulSteps; config.TraceTimings = configSection.Trace.TraceTimings; config.MinTracedDuration = configSection.Trace.MinTracedDuration; } foreach (var element in configSection.StepAssemblies) { Assembly stepAssembly = Assembly.Load(((StepAssemblyConfigElement)element).Assembly); config._additionalStepAssemblies.Add(stepAssembly); } return config; }
public TestExecutionEngine(IStepFormatter stepFormatter, ITestTracer testTracer, IErrorProvider errorProvider, IStepArgumentTypeConverter stepArgumentTypeConverter, RuntimeConfiguration runtimeConfiguration, IBindingRegistry bindingRegistry, IUnitTestRuntimeProvider unitTestRuntimeProvider, IDictionary<ProgrammingLanguage, IStepDefinitionSkeletonProvider> stepDefinitionSkeletonProviders, IContextManager contextManager) { this.errorProvider = errorProvider; this.contextManager = contextManager; this.stepDefinitionSkeletonProviders = stepDefinitionSkeletonProviders; this.unitTestRuntimeProvider = unitTestRuntimeProvider; this.bindingRegistry = bindingRegistry; this.runtimeConfiguration = runtimeConfiguration; this.testTracer = testTracer; this.stepFormatter = stepFormatter; this.stepArgumentTypeConverter = stepArgumentTypeConverter; this.currentStepDefinitionSkeletonProvider = stepDefinitionSkeletonProviders[ProgrammingLanguage.CSharp]; // fallback if feature initialization was not proper }
public static IObjectContainer CreateContainer(IRuntimeConfigurationProvider configurationProvider = null) { var container = new ObjectContainer(); RegisterDefaults(container); if (configurationProvider != null) container.RegisterInstanceAs(configurationProvider); configurationProvider = configurationProvider ?? container.Resolve<IRuntimeConfigurationProvider>(); var pluginLoader = container.Resolve<IRuntimePluginLoader>(); var plugins = configurationProvider.GetPlugins().Select(pd => LoadPlugin(pluginLoader, pd)).ToArray(); foreach (var plugin in plugins) { plugin.RegisterDefaults(container); } RuntimeConfiguration runtimeConfiguration = new RuntimeConfiguration(); foreach (var defaultsProvider in container.Resolve<IDictionary<string, IRuntimeConfigurationDefaultsProvider>>().Values) { defaultsProvider.SetDefaultConfiguration(runtimeConfiguration); } configurationProvider.LoadConfiguration(runtimeConfiguration); #if !BODI_LIMITEDRUNTIME if (runtimeConfiguration.CustomDependencies != null) container.RegisterFromConfiguration(runtimeConfiguration.CustomDependencies); #endif container.RegisterInstanceAs(runtimeConfiguration); if (runtimeConfiguration.TraceListenerType != null) container.RegisterTypeAs<ITraceListener>(runtimeConfiguration.TraceListenerType); if (runtimeConfiguration.RuntimeUnitTestProvider != null) container.RegisterInstanceAs(container.Resolve<IUnitTestRuntimeProvider>(runtimeConfiguration.RuntimeUnitTestProvider)); foreach (var plugin in plugins) { plugin.RegisterCustomizations(container, runtimeConfiguration); } return container; }
public TestExecutionEngine(IStepFormatter stepFormatter, ITestTracer testTracer, IErrorProvider errorProvider, IStepArgumentTypeConverter stepArgumentTypeConverter, RuntimeConfiguration runtimeConfiguration, IBindingRegistry bindingRegistry, IUnitTestRuntimeProvider unitTestRuntimeProvider, IStepDefinitionSkeletonProvider stepDefinitionSkeletonProvider, IContextManager contextManager, IStepDefinitionMatchService stepDefinitionMatchService, IDictionary<string, IStepErrorHandler> stepErrorHandlers, IBindingInvoker bindingInvoker) { this.errorProvider = errorProvider; this.bindingInvoker = bindingInvoker; this.contextManager = contextManager; this.unitTestRuntimeProvider = unitTestRuntimeProvider; this.stepDefinitionSkeletonProvider = stepDefinitionSkeletonProvider; this.bindingRegistry = bindingRegistry; this.runtimeConfiguration = runtimeConfiguration; this.testTracer = testTracer; this.stepFormatter = stepFormatter; this.stepArgumentTypeConverter = stepArgumentTypeConverter; this.stepErrorHandlers = stepErrorHandlers == null ? null : stepErrorHandlers.Values.ToArray(); this.stepDefinitionMatchService = stepDefinitionMatchService; }
public StepDefinitionMatchService(IBindingRegistry bindingRegistry, IStepArgumentTypeConverter stepArgumentTypeConverter, IObjectContainer objectContainer, RuntimeConfiguration runtimeConfiguration) { this.bindingRegistry = bindingRegistry; this.stepArgumentTypeConverter = stepArgumentTypeConverter; // var assemblyLoader = objectContainer.Resolve<IBindingAssemblyLoader>(); // var bindingAssemblies = new List<Assembly>() { };//;//TODO LC // assemblyLoader.Load("OrbisAccess.PublicSite.Specs") // bindingAssemblies.AddRange( // runtimeConfiguration.AdditionalStepAssemblies.Select(assemblyLoader.Load)); //foreach (Assembly assembly in bindingAssemblies) //{ // bindingRegistryBuilder.BuildBindingsFromAssembly(assembly); //} }
public static void UpdateConfigFromFileContent(RuntimeConfiguration runtimeConfiguration, string configFileContent) { XmlDocument configDocument; try { configDocument = new XmlDocument(); configDocument.LoadXml(configFileContent); } catch(Exception ex) { Debug.WriteLine(ex, "Config load error"); return; } var specFlowNode = configDocument.SelectSingleNode("/configuration/specFlow"); if (specFlowNode == null) return; var section = ConfigurationSectionHandler.CreateFromXml(specFlowNode); runtimeConfiguration.LoadConfiguration(section); }
public virtual IObjectContainer CreateContainer(IRuntimeConfigurationProvider configurationProvider = null) { var container = new ObjectContainer(); container.RegisterInstanceAs<ITestRunContainerBuilder>(this); RegisterDefaults(container); if (configurationProvider != null) container.RegisterInstanceAs(configurationProvider); configurationProvider = configurationProvider ?? container.Resolve<IRuntimeConfigurationProvider>(); var plugins = LoadPlugins(configurationProvider, container); foreach (var plugin in plugins) plugin.RegisterDependencies(container); RuntimeConfiguration runtimeConfiguration = new RuntimeConfiguration(); foreach (var plugin in plugins) plugin.RegisterConfigurationDefaults(runtimeConfiguration); configurationProvider.LoadConfiguration(runtimeConfiguration); #if !BODI_LIMITEDRUNTIME if (runtimeConfiguration.CustomDependencies != null) container.RegisterFromConfiguration(runtimeConfiguration.CustomDependencies); #endif container.RegisterInstanceAs(runtimeConfiguration); if (runtimeConfiguration.RuntimeUnitTestProvider != null) container.RegisterInstanceAs(container.Resolve<IUnitTestRuntimeProvider>(runtimeConfiguration.RuntimeUnitTestProvider)); foreach (var plugin in plugins) plugin.RegisterCustomizations(container, runtimeConfiguration); return container; }
public TestExecutionEngine(IStepFormatter stepFormatter, ITestTracer testTracer, IErrorProvider errorProvider, IStepArgumentTypeConverter stepArgumentTypeConverter, RuntimeConfiguration runtimeConfiguration, IBindingRegistry bindingRegistry, IUnitTestRuntimeProvider unitTestRuntimeProvider, IDictionary<ProgrammingLanguage, IStepDefinitionSkeletonProvider> stepDefinitionSkeletonProviders, IContextManager contextManager, IStepDefinitionMatchService stepDefinitionMatchService, IDictionary<string, IStepErrorHandler> stepErrorHandlers, IBindingInvoker bindingInvoker, IRuntimeBindingRegistryBuilder bindingRegistryBuilder) { this.errorProvider = errorProvider; //this.stepDefinitionMatcher = stepDefinitionMatcher; this.bindingInvoker = bindingInvoker; this.bindingRegistryBuilder = bindingRegistryBuilder; this.contextManager = contextManager; this.stepDefinitionSkeletonProviders = stepDefinitionSkeletonProviders; this.unitTestRuntimeProvider = unitTestRuntimeProvider; this.bindingRegistry = bindingRegistry; this.runtimeConfiguration = runtimeConfiguration; this.testTracer = testTracer; this.stepFormatter = stepFormatter; this.stepArgumentTypeConverter = stepArgumentTypeConverter; this.stepErrorHandlers = stepErrorHandlers == null ? null : stepErrorHandlers.Values.ToArray(); this.currentStepDefinitionSkeletonProvider = stepDefinitionSkeletonProviders[ProgrammingLanguage.CSharp]; // fallback if feature initialization was not proper this.stepDefinitionMatchService = stepDefinitionMatchService; }
public void RaiseConfigurationDefaults(RuntimeConfiguration runtimeConfiguration) { ConfigurationDefaults?.Invoke(this, new ConfigurationDefaultsEventArgs(runtimeConfiguration)); }
public BindingInvoker(RuntimeConfiguration runtimeConfiguration, IErrorProvider errorProvider) { this.runtimeConfiguration = runtimeConfiguration; this.errorProvider = errorProvider; }
public TestRunnerFactory(IObjectContainer objectContainer, RuntimeConfiguration runtimeConfiguration) { this.objectContainer = objectContainer; this.runtimeConfiguration = runtimeConfiguration; }
/* private bool IsSpecified(ConfigurationElement configurationElement) { return configurationElement != null && configurationElement.ElementInformation.IsPresent; } public void LoadConfiguration(ConfigurationSectionHandler configSection) { if (configSection == null) throw new ArgumentNullException("configSection"); if (IsSpecified(configSection.Language)) { FeatureLanguage = CultureInfo.GetCultureInfo(configSection.Language.Feature); this.ToolLanguage = string.IsNullOrEmpty(configSection.Language.Tool) ? CultureInfo.GetCultureInfo(configSection.Language.Feature) : CultureInfo.GetCultureInfo(configSection.Language.Tool); } if (IsSpecified(configSection.BindingCulture)) { this.BindingCulture = CultureInfo.GetCultureInfo(configSection.BindingCulture.Name); } if (IsSpecified(configSection.Runtime)) { this.DetectAmbiguousMatches = configSection.Runtime.DetectAmbiguousMatches; this.StopAtFirstError = configSection.Runtime.StopAtFirstError; this.MissingOrPendingStepsOutcome = configSection.Runtime.MissingOrPendingStepsOutcome; if (IsSpecified(configSection.Runtime.Dependencies)) { this.CustomDependencies = configSection.Runtime.Dependencies; } } if (IsSpecified(configSection.UnitTestProvider)) { if (!string.IsNullOrEmpty(configSection.UnitTestProvider.RuntimeProvider)) { //compatibility mode, we simulate a custom dependency this.RuntimeUnitTestProvider = "custom"; AddCustomDependency(configSection.UnitTestProvider.RuntimeProvider, typeof(IUnitTestRuntimeProvider), this.RuntimeUnitTestProvider); } else { this.RuntimeUnitTestProvider = configSection.UnitTestProvider.Name; } } if (IsSpecified(configSection.Trace)) { if (!string.IsNullOrEmpty(configSection.Trace.Listener)) // backwards compatibility { AddCustomDependency(configSection.Trace.Listener, typeof(ITraceListener)); } this.TraceSuccessfulSteps = configSection.Trace.TraceSuccessfulSteps; this.TraceTimings = configSection.Trace.TraceTimings; this.MinTracedDuration = configSection.Trace.MinTracedDuration; this.StepDefinitionSkeletonStyle = configSection.Trace.StepDefinitionSkeletonStyle; } foreach (var element in configSection.StepAssemblies) { var assemblyName = ((StepAssemblyConfigElement)element).Assembly; this.AdditionalStepAssemblies.Add(assemblyName); } } private void AddCustomDependency(string implementationType, Type interfaceType, string name = null) { if (this.CustomDependencies == null) this.CustomDependencies = new ContainerRegistrationCollection(); this.CustomDependencies.Add(implementationType, interfaceType.AssemblyQualifiedName, name); } */ #region Equality members protected bool Equals(RuntimeConfiguration other) { return Equals(FeatureLanguage, other.FeatureLanguage) && Equals(ToolLanguage, other.ToolLanguage) && Equals(BindingCulture, other.BindingCulture) && string.Equals(RuntimeUnitTestProvider, other.RuntimeUnitTestProvider) && DetectAmbiguousMatches.Equals(other.DetectAmbiguousMatches) && StopAtFirstError.Equals(other.StopAtFirstError) && MissingOrPendingStepsOutcome.Equals(other.MissingOrPendingStepsOutcome) && TraceSuccessfulSteps.Equals(other.TraceSuccessfulSteps) && TraceTimings.Equals(other.TraceTimings) && MinTracedDuration.Equals(other.MinTracedDuration) && StepDefinitionSkeletonStyle.Equals(other.StepDefinitionSkeletonStyle) && (AdditionalStepAssemblies ?? new List<string>()).SequenceEqual(other.AdditionalStepAssemblies ?? new List<string>()); }
public StepDefinitionRegexCalculator(RuntimeConfiguration runtimeConfiguration) { this.runtimeConfiguration = runtimeConfiguration; }
public StepDefinitionMatchServiceWithOnlySimpleTypeConverter(IBindingRegistry bindingRegistry, IObjectContainer objectContainer, RuntimeConfiguration runtimeConfiguration ) : base(bindingRegistry, new OnlySimpleConverter(),objectContainer,runtimeConfiguration) { }
public ErrorProvider(IStepFormatter stepFormatter, RuntimeConfiguration runtimeConfiguration, IUnitTestRuntimeProvider unitTestRuntimeProvider) { this.stepFormatter = stepFormatter; this.unitTestRuntimeProvider = unitTestRuntimeProvider; this.runtimeConfiguration = runtimeConfiguration; }
internal VsProjectScope(Project project, DteWithEvents dteWithEvents, GherkinFileEditorClassifications classifications, IVisualStudioTracer tracer, IIntegrationOptionsProvider integrationOptionsProvider, IObjectContainer objectContainer, RuntimeConfiguration runtimeConfiguration) { Classifications = classifications; this.project = project; this.dteWithEvents = dteWithEvents; this.tracer = tracer; m_objectContainer = objectContainer; m_runtimeConfiguration = runtimeConfiguration; this.integrationOptionsProvider = integrationOptionsProvider; var integrationOptions = integrationOptionsProvider.GetOptions(); parser = new GherkinTextBufferParser(this, tracer); //TODO: enable when analizer is implemented // if (integrationOptions.EnableAnalysis) // analyzer = new GherkinScopeAnalyzer(this, visualStudioTracer); GherkinProcessingScheduler = new GherkinProcessingScheduler(tracer, integrationOptions.EnableAnalysis); GeneratorServices = new VsGeneratorServices(project, new VsSpecFlowConfigurationReader(project, tracer), tracer); }
public ConfigurationDefaultsEventArgs(RuntimeConfiguration runtimeConfiguration) { this.RuntimeConfiguration = runtimeConfiguration; }
public CustomizeGlobalDependenciesEventArgs(ObjectContainer objectContainer, RuntimeConfiguration runtimeConfiguration) : base(objectContainer) { this.RuntimeConfiguration = runtimeConfiguration; }
public void RaiseCustomizeGlobalDependencies(ObjectContainer container, RuntimeConfiguration runtimeConfiguration) { CustomizeGlobalDependencies?.Invoke(this, new CustomizeGlobalDependenciesEventArgs(container, runtimeConfiguration)); }
public void LoadConfiguration(RuntimeConfiguration defaultConfiguration) { defaultConfiguration.LoadConfiguration(); }
protected bool Equals(RuntimeConfiguration other) { return(Equals(FeatureLanguage, other.FeatureLanguage) && Equals(ToolLanguage, other.ToolLanguage) && Equals(BindingCulture, other.BindingCulture) && string.Equals(RuntimeUnitTestProvider, other.RuntimeUnitTestProvider) && DetectAmbiguousMatches.Equals(other.DetectAmbiguousMatches) && StopAtFirstError.Equals(other.StopAtFirstError) && MissingOrPendingStepsOutcome.Equals(other.MissingOrPendingStepsOutcome) && TraceSuccessfulSteps.Equals(other.TraceSuccessfulSteps) && TraceTimings.Equals(other.TraceTimings) && MinTracedDuration.Equals(other.MinTracedDuration) && StepDefinitionSkeletonStyle.Equals(other.StepDefinitionSkeletonStyle) && (AdditionalStepAssemblies ?? new List <string>()).SequenceEqual(other.AdditionalStepAssemblies ?? new List <string>())); }
public void LoadConfiguration(RuntimeConfiguration defaultConfiguration) { ConfigurationSectionHandler section = GetSection(); defaultConfiguration.LoadConfiguration(section); }
public void RegisterCustomizations(ObjectContainer container, RuntimeConfiguration runtimeConfiguration) { if (runtimeConfiguration.StopAtFirstError) container.RegisterTypeAs<CustomTestRunnerFactory, ITestRunnerFactory>(); }
public void LoadConfiguration(RuntimeConfiguration defaultConfiguration) { defaultConfiguration.LoadConfiguration(); }
public void CanLoadConfigFromConfigFile() { var runtimeConfiguration = new RuntimeConfiguration(); runtimeConfiguration.LoadConfiguration(); }
public IEnumerable <PluginDescriptor> GetPlugins() { return(RuntimeConfiguration.GetPlugins()); }
public virtual IObjectContainer CreateGlobalContainer(IRuntimeConfigurationProvider configurationProvider = null) { var container = new ObjectContainer(); container.RegisterInstanceAs<IContainerBuilder>(this); RegisterDefaults(container); if (configurationProvider != null) container.RegisterInstanceAs(configurationProvider); configurationProvider = configurationProvider ?? container.Resolve<IRuntimeConfigurationProvider>(); container.RegisterTypeAs<RuntimePluginEvents, RuntimePluginEvents>(); //NOTE: we need this unnecessary registration, due to a bug in BoDi (does not inherit non-registered objects) var runtimePluginEvents = container.Resolve<RuntimePluginEvents>(); LoadPlugins(configurationProvider, container, runtimePluginEvents); runtimePluginEvents.RaiseRegisterGlobalDependencies(container); RuntimeConfiguration runtimeConfiguration = new RuntimeConfiguration(); runtimePluginEvents.RaiseConfigurationDefaults(runtimeConfiguration); configurationProvider.LoadConfiguration(runtimeConfiguration); #if !BODI_LIMITEDRUNTIME if (runtimeConfiguration.CustomDependencies != null) container.RegisterFromConfiguration(runtimeConfiguration.CustomDependencies); #endif container.RegisterInstanceAs(runtimeConfiguration); if (runtimeConfiguration.RuntimeUnitTestProvider != null) container.RegisterInstanceAs(container.Resolve<IUnitTestRuntimeProvider>(runtimeConfiguration.RuntimeUnitTestProvider)); runtimePluginEvents.RaiseCustomizeGlobalDependencies(container, runtimeConfiguration); return container; }