private void Initialize()
{
specFlowProjectConfiguration = LoadConfiguration();
gherkinDialectServices = new GherkinDialectServices(specFlowProjectConfiguration.GeneratorConfiguration.FeatureLanguage);
appConfigTracker = new VsProjectFileTracker(project, "App.config", dteWithEvents, visualStudioTracer);
appConfigTracker.FileChanged += AppConfigTrackerOnFileChanged;
appConfigTracker.FileOutOfScope += AppConfigTrackerOnFileOutOfScope;
var enableAnalysis = integrationOptionsProvider.GetOptions().EnableAnalysis;
if (enableAnalysis)
{
featureFilesTracker = new ProjectFeatureFilesTracker(this);
featureFilesTracker.Ready += FeatureFilesTrackerOnReady;
bindingFilesTracker = new BindingFilesTracker(this);
stepSuggestionProvider = new VsStepSuggestionProvider(this);
bindingMatchService = new BindingMatchService(stepSuggestionProvider);
}
initialized = true;
if (enableAnalysis)
{
stepSuggestionProvider.Initialize();
bindingFilesTracker.Initialize();
featureFilesTracker.Initialize();
bindingFilesTracker.Run();
featureFilesTracker.Run();
}
}
public NoProjectScope(GherkinFileEditorClassifications classifications, IVisualStudioTracer visualStudioTracer)
{
GherkinTextBufferParser = new GherkinTextBufferParser(this, visualStudioTracer);
GherkinProcessingScheduler = new GherkinProcessingScheduler(visualStudioTracer);
SpecFlowProjectConfiguration = new SpecFlowProjectConfiguration();
GherkinDialectServices = new GherkinDialectServices(SpecFlowProjectConfiguration.GeneratorConfiguration.FeatureLanguage);
Classifications = classifications;
}
private void Initialize()
{
tracer.Trace("Initializing...", "VsProjectScope");
try
{
specFlowProjectConfiguration = LoadConfiguration();
gherkinDialectServices = new GherkinDialectServices(specFlowProjectConfiguration.GeneratorConfiguration.FeatureLanguage);
appConfigTracker = new VsProjectFileTracker(project, "App.config", dteWithEvents, tracer);
appConfigTracker.FileChanged += AppConfigTrackerOnFileChanged;
appConfigTracker.FileOutOfScope += AppConfigTrackerOnFileOutOfScope;
var enableAnalysis = integrationOptionsProvider.GetOptions().EnableAnalysis;
if (enableAnalysis)
{
featureFilesTracker = new ProjectFeatureFilesTracker(this);
featureFilesTracker.Ready += FeatureFilesTrackerOnReady;
bindingFilesTracker = new BindingFilesTracker(this);
stepSuggestionProvider = new VsStepSuggestionProvider(this);
stepSuggestionProvider.Ready += StepSuggestionProviderOnReady;
stepDefinitionMatchService = new StepDefinitionMatchServiceWithOnlySimpleTypeConverter(stepSuggestionProvider, m_objectContainer, m_runtimeConfiguration);
}
tracer.Trace("Initialized", "VsProjectScope");
initialized = true;
if (enableAnalysis)
{
tracer.Trace("Starting analysis services...", "VsProjectScope");
stepSuggestionProvider.Initialize();
bindingFilesTracker.Initialize();
featureFilesTracker.Initialize();
LoadStepMap();
bindingFilesTracker.Run();
featureFilesTracker.Run();
dteWithEvents.OnBuildDone += BuildEventsOnOnBuildDone;
tracer.Trace("Analysis services started", "VsProjectScope");
}
else
{
tracer.Trace("Analysis services disabled", "VsProjectScope");
}
}
catch (Exception exception)
{
tracer.Trace("Exception: " + exception, "VsProjectScope");
}
}
/// <summary>
/// The register customizations.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="generatorConfiguration">The generator configuration.</param>
public void RegisterCustomizations(ObjectContainer container, SpecFlowProjectConfiguration generatorConfiguration)
{
container.RegisterTypeAs <SpecBindConfigurationProvider, ISpecBindConfigurationProvider>();
var unitTestGenProvider = generatorConfiguration.GeneratorConfiguration.GeneratorUnitTestProvider;
if (string.Equals(unitTestGenProvider, "mstest", StringComparison.OrdinalIgnoreCase) ||
string.Equals(unitTestGenProvider, "mstest.2010", StringComparison.OrdinalIgnoreCase))
{
container.RegisterTypeAs <SpecBindTestGeneratorProvider, IUnitTestGeneratorProvider>();
}
}
public static IObjectContainer CreateContainer(SpecFlowConfigurationHolder configurationHolder, ProjectSettings projectSettings)
{
var container = new ObjectContainer();
container.RegisterInstanceAs(projectSettings);
RegisterDefaults(container);
var configurationProvider = container.Resolve <IGeneratorConfigurationProvider>();
var plugins = LoadPlugins(container, configurationProvider, configurationHolder);
foreach (var plugin in plugins)
{
plugin.RegisterDependencies(container);
}
var specFlowConfiguration = new SpecFlowProjectConfiguration();
foreach (var plugin in plugins)
{
plugin.RegisterConfigurationDefaults(specFlowConfiguration);
}
configurationProvider.LoadConfiguration(configurationHolder, specFlowConfiguration);
if (specFlowConfiguration.GeneratorConfiguration.CustomDependencies != null)
{
container.RegisterFromConfiguration(specFlowConfiguration.GeneratorConfiguration.CustomDependencies);
}
container.RegisterInstanceAs(specFlowConfiguration);
container.RegisterInstanceAs(specFlowConfiguration.GeneratorConfiguration);
container.RegisterInstanceAs(specFlowConfiguration.RuntimeConfiguration);
var generatorInfo = container.Resolve <IGeneratorInfoProvider>().GetGeneratorInfo();
container.RegisterInstanceAs(generatorInfo);
container.RegisterInstanceAs(container.Resolve <CodeDomHelper>(projectSettings.ProjectPlatformSettings.Language));
if (specFlowConfiguration.GeneratorConfiguration.GeneratorUnitTestProvider != null)
{
container.RegisterInstanceAs(container.Resolve <IUnitTestGeneratorProvider>(specFlowConfiguration.GeneratorConfiguration.GeneratorUnitTestProvider));
}
foreach (var plugin in plugins)
{
plugin.RegisterCustomizations(container, specFlowConfiguration);
}
return(container);
}
private static SpecFlowProjectConfiguration LoadSpecFlowConfigurationFromDteProjectInternal(Project project)
{
SpecFlowProjectConfiguration configuration = new SpecFlowProjectConfiguration();
ProjectItem projectItem = VsxHelper.FindProjectItemByProjectRelativePath(project, "app.config");
if (projectItem != null)
{
string configFileContent = VsxHelper.GetFileContent(projectItem);
GeneratorConfigurationReader.UpdateConfigFromFileContent(configuration.GeneratorConfiguration, configFileContent);
RuntimeConfigurationReader.UpdateConfigFromFileContent(configuration.RuntimeConfiguration, configFileContent);
}
return(configuration);
}
public void Should_be_able_to_change_default_configuration_from_a_plugin()
{
var pluginWithCustomConfiguration = new PluginWithCustomConfiguration(conf => conf.SpecFlowConfiguration.StopAtFirstError = true);
var generatorPluginEvents = new GeneratorPluginEvents();
pluginWithCustomConfiguration.Initialize(generatorPluginEvents, new GeneratorPluginParameters(), new UnitTestProviderConfiguration());
var specFlowProjectConfiguration = new SpecFlowProjectConfiguration();
generatorPluginEvents.RaiseConfigurationDefaults(specFlowProjectConfiguration);
specFlowProjectConfiguration.SpecFlowConfiguration.StopAtFirstError.Should().BeTrue();
}
public static IObjectContainer CreateContainer(SpecFlowConfigurationHolder configurationHolder, ProjectSettings projectSettings, IEnumerable <string> generatorPlugins)
{
var container = new ObjectContainer();
container.RegisterInstanceAs(projectSettings);
RegisterDefaults(container);
var configurationProvider = container.Resolve <IGeneratorConfigurationProvider>();
var generatorPluginEvents = container.Resolve <GeneratorPluginEvents>();
var unitTestProviderConfigration = container.Resolve <UnitTestProviderConfiguration>();
var specFlowConfiguration = new SpecFlowProjectConfiguration();
specFlowConfiguration.SpecFlowConfiguration = configurationProvider.LoadConfiguration(specFlowConfiguration.SpecFlowConfiguration, configurationHolder);
LoadPlugins(container, generatorPluginEvents, unitTestProviderConfigration, generatorPlugins);
generatorPluginEvents.RaiseRegisterDependencies(container);
generatorPluginEvents.RaiseConfigurationDefaults(specFlowConfiguration);
if (specFlowConfiguration.SpecFlowConfiguration.GeneratorCustomDependencies != null)
{
container.RegisterFromConfiguration(specFlowConfiguration.SpecFlowConfiguration.GeneratorCustomDependencies);
}
container.RegisterInstanceAs(specFlowConfiguration);
container.RegisterInstanceAs(specFlowConfiguration.SpecFlowConfiguration);
var generatorInfo = container.Resolve <IGeneratorInfoProvider>().GetGeneratorInfo();
container.RegisterInstanceAs(generatorInfo);
container.RegisterInstanceAs(container.Resolve <CodeDomHelper>(projectSettings.ProjectPlatformSettings.Language));
if (unitTestProviderConfigration != null)
{
container.RegisterInstanceAs(container.Resolve <IUnitTestGeneratorProvider>(unitTestProviderConfigration.UnitTestProvider ?? ConfigDefaults.UnitTestProviderName));
}
generatorPluginEvents.RaiseCustomizeDependencies(container, specFlowConfiguration);
container.Resolve <IConfigurationLoader>().TraceConfigSource(container.Resolve <ITraceListener>(), specFlowConfiguration.SpecFlowConfiguration);
return(container);
}
public AttributeGeneratorProvider(CodeDomHelper codeDomHelper, SpecFlowProjectConfiguration configuration)
{
string runtimeUnitTestProvider = configuration.SpecFlowConfiguration.UnitTestProvider;
switch (runtimeUnitTestProvider.ToUpper(CultureInfo.InvariantCulture))
{
case "NUNIT":
baseGeneratorProvider = new NUnit3TestGeneratorProvider(codeDomHelper);
break;
default:
throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "The specified unit test provider '{0}' is not usable with NUnit wrapper",
runtimeUnitTestProvider));
}
this.codeDomHelper = codeDomHelper;
}
private static void LoadPlugins(ObjectContainer container, IGeneratorConfigurationProvider configurationProvider, SpecFlowConfigurationHolder configurationHolder,
GeneratorPluginEvents generatorPluginEvents, SpecFlowProjectConfiguration specFlowConfiguration, UnitTestProviderConfiguration unitTestProviderConfigration,
IEnumerable <string> generatorPlugins)
{
// initialize plugins that were registered from code
foreach (var generatorPlugin in container.Resolve <IDictionary <string, IGeneratorPlugin> >().Values)
{
// these plugins cannot have parameters
generatorPlugin.Initialize(generatorPluginEvents, new GeneratorPluginParameters(), unitTestProviderConfigration);
}
var pluginLoader = container.Resolve <IGeneratorPluginLoader>();
foreach (var generatorPlugin in generatorPlugins)
{
//todo: should set the parameters, and do not pass empty
var pluginDescriptor = new PluginDescriptor(Path.GetFileNameWithoutExtension(generatorPlugin), generatorPlugin, PluginType.Generator, string.Empty);
LoadPlugin(pluginDescriptor, pluginLoader, generatorPluginEvents, unitTestProviderConfigration);
}
}
public void Should_be_able_to_register_further_dependencies_based_on_the_configuration() //generatorPluginEvents.RaiseCustomizeDependencies();
{
var pluginWithCustomization = new PluginWithCustomization();
var generatorPluginEvents = new GeneratorPluginEvents();
pluginWithCustomization.Initialize(generatorPluginEvents, new GeneratorPluginParameters(), new UnitTestProviderConfiguration());
var container = new ObjectContainer();
var specFlowProjectConfiguration = new SpecFlowProjectConfiguration();
generatorPluginEvents.RaiseCustomizeDependencies(container, specFlowProjectConfiguration);
container.ResolveAll <ITestHeaderWriter>().Should().BeEmpty();
specFlowProjectConfiguration.SpecFlowConfiguration.StopAtFirstError = true;
generatorPluginEvents.RaiseCustomizeDependencies(container, specFlowProjectConfiguration);
var customHeaderWriter = container.Resolve <ITestHeaderWriter>();
customHeaderWriter.Should().BeOfType <CustomHeaderWriter>();
}
private void AppConfigTrackerOnFileChanged(ProjectItem appConfigItem)
{
var newConfig = LoadConfiguration();
if (newConfig.Equals(SpecFlowProjectConfiguration))
{
return;
}
bool dialectServicesChanged = !newConfig.GeneratorConfiguration.FeatureLanguage.Equals(GherkinDialectServices.DefaultLanguage);
specFlowProjectConfiguration = newConfig;
OnSpecFlowProjectConfigurationChanged();
if (dialectServicesChanged)
{
gherkinDialectServices = new GherkinDialectServices(SpecFlowProjectConfiguration.GeneratorConfiguration.FeatureLanguage);
OnGherkinDialectServicesChanged();
}
}
public NCrunchAttributeGeneratorProvider(CodeDomHelper codeDomHelper, SpecFlowProjectConfiguration configuration)
{
string runtimeUnitTestProvider = configuration.RuntimeConfiguration.RuntimeUnitTestProvider;
switch (runtimeUnitTestProvider.ToUpper(CultureInfo.InvariantCulture))
{
case "NUNIT":
baseGeneratorProvider = new NUnitTestGeneratorProvider(codeDomHelper);
break;
case "MSTEST":
baseGeneratorProvider = new MsTest2010GeneratorProvider(codeDomHelper);
break;
case "MSTEST.2010":
baseGeneratorProvider = new MsTest2010GeneratorProvider(codeDomHelper);
break;
case "MSTEST.2008":
baseGeneratorProvider = new MsTestGeneratorProvider(codeDomHelper);
break;
case "XUNIT":
baseGeneratorProvider = new XUnitTestGeneratorProvider(codeDomHelper);
break;
case "MBUNIT":
baseGeneratorProvider = new MbUnitTestGeneratorProvider(codeDomHelper);
break;
case "MBUNIT.3":
baseGeneratorProvider = new MbUnit3TestGeneratorProvider(codeDomHelper);
break;
default:
throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "The specified unit test provider '{0}' is not usable with NCrunch wrapper",
runtimeUnitTestProvider));
}
this.codeDomHelper = codeDomHelper;
}
public ExternalDataFeaturePatcher(SpecFlowProjectConfiguration configuration, ITagFilterMatcher tagFilterMatcher, ITestDataProvider testDataProvider)
{
_tagFilterMatcher = tagFilterMatcher;
_testDataProvider = testDataProvider;
}
public void RaiseCustomizeDependencies(ObjectContainer container, SpecFlowProjectConfiguration specFlowProjectConfiguration)
{
CustomizeDependencies?.Invoke(this, new CustomizeDependenciesEventArgs(container, specFlowProjectConfiguration));
}
public void RaiseConfigurationDefaults(SpecFlowProjectConfiguration specFlowProjectConfiguration)
{
ConfigurationDefaults?.Invoke(this, new ConfigurationDefaultsEventArgs(specFlowProjectConfiguration));
}
public SpecFlowProject()
{
ProjectSettings = new ProjectSettings();
Configuration = new SpecFlowProjectConfiguration();
}
public void RegisterCustomizations(ObjectContainer container, SpecFlowProjectConfiguration generatorConfiguration)
{
container.RegisterTypeAs <RemoveRetryTagFromCategoriesDecarator, ITestClassTagDecorator>("retry");
container.RegisterTypeAs <RemoveRetryTagFromCategoriesDecarator, ITestMethodTagDecorator>("retry");
}
public void RegisterCustomizations(BoDi.ObjectContainer container, SpecFlowProjectConfiguration generatorConfiguration)
{
container.RegisterTypeAs <AttributeGenerator, ITestMethodTagDecorator>("mka.AttributeGenerator");
}
public void RegisterConfigurationDefaults(SpecFlowProjectConfiguration specFlowConfiguration)
{
}
public void RegisterCustomizations(ObjectContainer container, SpecFlowProjectConfiguration generatorConfiguration)
{
container.RegisterTypeAs <NUnitBrowserTestGenerator, IUnitTestGeneratorProvider>();
}
public void RegisterCustomizations(ObjectContainer container, SpecFlowProjectConfiguration generatorConfiguration)
{
container.RegisterTypeAs <CustomGeneratorProvider, IUnitTestGeneratorProvider>();
container.RegisterTypeAs <CustomXUnitTestRuntimeProvider, IUnitTestRuntimeProvider>();
}
public void RegisterCustomizations(ObjectContainer container,
SpecFlowProjectConfiguration generatorConfiguration)
{
}
public ConfigurationDefaultsEventArgs(SpecFlowProjectConfiguration specFlowProjectConfiguration)
{
this.SpecFlowProjectConfiguration = specFlowProjectConfiguration;
}
/// <summary>
/// The register customizations.
/// </summary>
/// <param name="container">
/// The container.
/// </param>
/// <param name="generatorConfiguration">
/// The generator configuration.
/// </param>
public void RegisterCustomizations(ObjectContainer container,
SpecFlowProjectConfiguration generatorConfiguration)
{
container.RegisterTypeAs <NCrunchAttributeGeneratorProvider, IUnitTestGeneratorProvider>();
//container.RegisterTypeAs<MsTest2010RuntimeProvider, IUnitTestRuntimeProvider>();
}
private static void LoadPlugins(ObjectContainer container, IGeneratorConfigurationProvider configurationProvider, SpecFlowConfigurationHolder configurationHolder, GeneratorPluginEvents generatorPluginEvents, SpecFlowProjectConfiguration specFlowConfiguration)
{
// initialize plugins that were registered from code
foreach (var generatorPlugin in container.Resolve <IDictionary <string, IGeneratorPlugin> >().Values)
{
// these plugins cannot have parameters
generatorPlugin.Initialize(generatorPluginEvents, new GeneratorPluginParameters());
}
var pluginLoader = container.Resolve <IGeneratorPluginLoader>();
foreach (var pluginDescriptor in configurationProvider.GetPlugins(specFlowConfiguration.SpecFlowConfiguration, configurationHolder).Where(pd => (pd.Type & PluginType.Generator) != 0))
{
LoadPlugin(pluginDescriptor, pluginLoader, generatorPluginEvents);
}
}
public SpecFlowProject()
{
ProjectSettings = new ProjectSettings();
FeatureFiles = new List <FeatureFileInput>();
Configuration = new SpecFlowProjectConfiguration();
}
public CustomizeDependenciesEventArgs(ObjectContainer objectContainer, SpecFlowProjectConfiguration specFlowProjectConfiguration)
: base(objectContainer)
{
this.SpecFlowProjectConfiguration = specFlowProjectConfiguration;
}
