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;
}
