private SpecFlowProject LoadAppConfig(SpecFlowProject specFlowProject, XDocument xDocument, string projectFolder, bool newProjectSystem)
{
var appConfigFile = GetAppConfigFile(xDocument, newProjectSystem, projectFolder);
SpecFlowConfigurationHolder configurationHolder = null;
if (!string.IsNullOrWhiteSpace(appConfigFile))
{
var configFilePath = Path.Combine(projectFolder, appConfigFile);
var configFileContent = File.ReadAllText(configFilePath);
configurationHolder = GetConfigurationHolderFromFileContent(configFileContent);
}
var jsonConfigFile = GetJsonConfigFile(xDocument, newProjectSystem, projectFolder);
if (!string.IsNullOrWhiteSpace(jsonConfigFile))
{
var configFilePath = Path.Combine(projectFolder, jsonConfigFile);
var configFileContent = File.ReadAllText(configFilePath);
configurationHolder = new SpecFlowConfigurationHolder(ConfigSource.Json, configFileContent);
}
if (configurationHolder != null)
{
specFlowProject.ProjectSettings.ConfigurationHolder = configurationHolder;
specFlowProject.Configuration = _configurationLoader.LoadConfiguration(configurationHolder);
}
return(specFlowProject);
}
public void Should_be_able_to_register_further_dependencies_based_on_the_configuration()
{
var configurationHolder = GetConfigWithPlugin();
GeneratorContainerBuilder.DefaultDependencyProvider = new TestDefaultDependencyProvider(new PluginWithCustomization());
// with default settings, the plugin should not change the header writer
var container = CreateDefaultContainer(configurationHolder);
var testHeaderWriter = container.Resolve <ITestHeaderWriter>();
testHeaderWriter.Should().BeOfType <TestHeaderWriter>();
// with StopAtFirstError == true, we should get a custom factory
var specialConfiguratuion = new SpecFlowConfigurationHolder(ConfigSource.AppConfig, string.Format(@"<specFlow>
<plugins>
<add name=""MyCompany.MyPlugin"" />
</plugins>
<runtime stopAtFirstError=""true"" />
</specFlow>"));
container = CreateDefaultContainer(specialConfiguratuion);
var customHeaderWriter = container.Resolve <ITestHeaderWriter>();
customHeaderWriter.Should().BeOfType <CustomHeaderWriter>();
}
public void Should_be_able_to_construct_a_test_class()
{
const string testProject = "TestSample.DefaultSettings";
const string featureFile = "BrowserRequiredTest.feature";
var testProjectFolder = Path.Combine(AssemblyDirectory, @"..\..\..\", testProject);
var configurationHolder = new SpecFlowConfigurationHolder(AppConfig);
var projectSettings = new ProjectSettings
{
AssemblyName = testProject,
DefaultNamespace = testProject,
ProjectName = testProject,
ProjectFolder = testProjectFolder,
ConfigurationHolder = configurationHolder,
ProjectPlatformSettings = new ProjectPlatformSettings()
};
var specflowProject = new SpecFlowProject {
ProjectSettings = projectSettings
};
var featurefileInput = specflowProject.GetOrCreateFeatureFile(featureFile);
var container = GeneratorContainerBuilder.CreateContainer(configurationHolder, projectSettings);
var generator = container.Resolve <ITestGenerator>();
var testFile = generator.GenerateTestFile(featurefileInput, new GenerationSettings());
var testFileContent = testFile.GeneratedTestCode;
Console.WriteLine(testFileContent);
Assert.That(testFile.Success);
}
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);
}
public void Should_be_able_to_specify_a_plugin_with_parameters()
{
var configurationHolder = new SpecFlowConfigurationHolder(ConfigSource.AppConfig, string.Format(@"<specFlow>
<plugins>
<add name=""MyCompany.MyPlugin"" parameters=""foo, bar"" />
</plugins>
</specFlow>"));
var pluginMock = new Mock <IGeneratorPlugin>();
GeneratorContainerBuilder.DefaultDependencyProvider = new TestDefaultDependencyProvider(pluginMock.Object);
CreateDefaultContainer(configurationHolder);
pluginMock.Verify(p => p.Initialize(It.IsAny <GeneratorPluginEvents>(), It.Is <GeneratorPluginParameters>(pp => pp.Parameters == "foo, bar")));
}
public virtual SpecFlowProjectConfiguration LoadConfiguration(SpecFlowConfigurationHolder configurationHolder, IProjectReference projectReference)
{
SpecFlowProjectConfiguration configuration = new SpecFlowProjectConfiguration();
if (configurationHolder != null && configurationHolder.HasConfiguration)
{
ConfigurationSectionHandler specFlowConfigSection = ConfigurationSectionHandler.CreateFromXml(configurationHolder.XmlString);
if (specFlowConfigSection != null)
{
configuration.GeneratorConfiguration.UpdateFromConfigFile(specFlowConfigSection);
configuration.RuntimeConfiguration.UpdateFromConfigFile(specFlowConfigSection);
}
}
configuration.GeneratorConfiguration.GeneratorVersion = GetGeneratorVersion(projectReference);
return(configuration);
}
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 virtual void LoadConfiguration(SpecFlowConfigurationHolder configurationHolder, SpecFlowProjectConfiguration configuration)
{
try
{
if (configurationHolder != null && configurationHolder.HasConfiguration)
{
ConfigurationSectionHandler specFlowConfigSection =
ConfigurationSectionHandler.CreateFromXml(configurationHolder.XmlString);
if (specFlowConfigSection != null)
{
UpdateGeneratorConfiguration(configuration, specFlowConfigSection);
UpdateRuntimeConfiguration(configuration, specFlowConfigSection);
}
}
}
catch (Exception ex)
{
throw new ConfigurationErrorsException("SpecFlow configuration error", ex);
}
}
public IEnumerable <PluginDescriptor> GetPlugins(SpecFlowConfigurationHolder configurationHolder)
{
try
{
if (configurationHolder != null && configurationHolder.HasConfiguration)
{
ConfigurationSectionHandler section = ConfigurationSectionHandler.CreateFromXml(configurationHolder.XmlString);
if (section != null && section.Plugins != null)
{
return(section.Plugins.Select(pce => pce.ToPluginDescriptor()));
}
}
return(Enumerable.Empty <PluginDescriptor>());
}
catch (Exception ex)
{
throw new ConfigurationErrorsException("SpecFlow configuration error", ex);
}
}
public static IObjectContainer CreateContainer(SpecFlowConfigurationHolder configurationHolder)
{
var configLoader = new RuntimeSpecFlowProjectConfigurationLoader();
var specFlowConfiguration = configLoader.LoadConfiguration(configurationHolder, new AppDomainProjectReference());
var container = new ObjectContainer();
container.RegisterInstanceAs(specFlowConfiguration);
container.RegisterInstanceAs(specFlowConfiguration.GeneratorConfiguration);
container.RegisterInstanceAs(specFlowConfiguration.RuntimeConfiguration);
RegisterDefaults(container);
if (specFlowConfiguration.GeneratorConfiguration.CustomDependencies != null)
{
container.RegisterFromConfiguration(specFlowConfiguration.GeneratorConfiguration.CustomDependencies);
}
return(container);
}
public void Should_create_custom_generator_when_configured_so()
{
var configurationHolder = new SpecFlowConfigurationHolder(string.Format(@"
<specFlow>
<generator>
<dependencies>
<register type=""{0}"" as=""{1}""/>
</dependencies>
</generator>
</specFlow>",
typeof(DummyGenerator).AssemblyQualifiedName,
typeof(ITestGenerator).AssemblyQualifiedName));
var projectSettings = net35CSProjectSettings;
projectSettings.ConfigurationHolder = configurationHolder;
var generator = factory.CreateGenerator(projectSettings);
generator.ShouldBeType(typeof(DummyGenerator));
}
public void Should_create_custom_generator_when_configured_so()
{
var configurationHolder = new SpecFlowConfigurationHolder(ConfigSource.AppConfig, string.Format(@"
<specFlow>
<generator>
<dependencies>
<register type=""{0}"" as=""{1}""/>
</dependencies>
</generator>
</specFlow>",
typeof(DummyGenerator).AssemblyQualifiedName,
typeof(ITestGenerator).AssemblyQualifiedName));
var projectSettings = net35CSProjectSettings;
projectSettings.ConfigurationHolder = configurationHolder;
var generator = _factory.CreateGenerator(projectSettings, Enumerable.Empty <GeneratorPluginInfo>());
generator.Should().BeOfType <DummyGenerator>();
}
public IObjectContainer BuildGeneratorContainer(
SpecFlowConfigurationHolder specFlowConfigurationHolder,
ProjectSettings projectSettings,
IReadOnlyCollection <GeneratorPluginInfo> generatorPluginInfos,
IObjectContainer rootObjectContainer)
{
var objectContainer = _generatorContainerBuilder.CreateContainer(specFlowConfigurationHolder, projectSettings, generatorPluginInfos, rootObjectContainer);
objectContainer.RegisterTypeAs <ProjectCodeBehindGenerator, IProjectCodeBehindGenerator>();
objectContainer.RegisterTypeAs <AnalyticsEventProvider, IAnalyticsEventProvider>();
if (_generateFeatureFileCodeBehindTaskConfiguration.OverrideFeatureFileCodeBehindGenerator is null)
{
objectContainer.RegisterTypeAs <FeatureFileCodeBehindGenerator, IFeatureFileCodeBehindGenerator>();
}
else
{
objectContainer.RegisterInstanceAs(_generateFeatureFileCodeBehindTaskConfiguration.OverrideFeatureFileCodeBehindGenerator);
}
return(objectContainer);
}
public void Should_create_custom_generator_when_configured_so()
{
var configurationHolder = new SpecFlowConfigurationHolder(string.Format(@"
<specFlow>
<generator>
<dependencies>
<register type=""{0}"" as=""{1}""/>
</dependencies>
</generator>
</specFlow>",
typeof(DummyGenerator).AssemblyQualifiedName,
typeof(ITestGenerator).AssemblyQualifiedName));
var projectSettings = new ProjectSettings();
projectSettings.ConfigurationHolder = configurationHolder;
using (var remoteFactory = CreateRemoteAppDomainTestGeneratorFactory())
{
var generator = remoteFactory.CreateGenerator(projectSettings);
generator.ToString().Should().Be("DummyGenerator"); // since the type is wrapped, we can only check it this way
}
}
public static IObjectContainer CreateContainer(SpecFlowConfigurationHolder configurationHolder)
{
var container = new ObjectContainer();
RegisterDefaults(container);
var specFlowConfiguration = container.Resolve <ISpecFlowProjectConfigurationLoader>()
.LoadConfiguration(configurationHolder);
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);
return(container);
}
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 static SpecFlowProjectConfiguration LoadConfiguration(this IGeneratorConfigurationProvider configurationProvider, SpecFlowConfigurationHolder configurationHolder)
{
SpecFlowProjectConfiguration configuration = new SpecFlowProjectConfiguration();
configuration.SpecFlowConfiguration = configurationProvider.LoadConfiguration(configuration.SpecFlowConfiguration, configurationHolder);
return(configuration);
}
private IObjectContainer CreateDefaultContainer(SpecFlowConfigurationHolder configurationHolder)
{
return(GeneratorContainerBuilder.CreateContainer(configurationHolder, new ProjectSettings(), Enumerable.Empty <string>()));
}
private static IGeneratorPlugin[] LoadPlugins(ObjectContainer container, IGeneratorConfigurationProvider configurationProvider, SpecFlowConfigurationHolder configurationHolder)
{
var plugins = container.Resolve <IDictionary <string, IGeneratorPlugin> >().Values.AsEnumerable();
var pluginLoader = container.Resolve <IGeneratorPluginLoader>();
plugins = plugins.Concat(configurationProvider.GetPlugins(configurationHolder).Where(pd => (pd.Type & PluginType.Generator) != 0).Select(pd => LoadPlugin(pluginLoader, pd)));
return(plugins.ToArray());
}
private static void LoadPlugins(ObjectContainer container, IGeneratorConfigurationProvider configurationProvider, SpecFlowConfigurationHolder configurationHolder, GeneratorPluginEvents generatorPluginEvents)
{
// 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(configurationHolder).Where(pd => (pd.Type & PluginType.Generator) != 0))
{
LoadPlugin(pluginDescriptor, pluginLoader, generatorPluginEvents);
}
}
public IEnumerable <PluginDescriptor> GetPlugins(SpecFlowConfiguration specFlowConfiguration, SpecFlowConfigurationHolder specFlowConfigurationHolder)
{
var config = LoadConfiguration(specFlowConfiguration, specFlowConfigurationHolder);
return(config.Plugins);
}
public virtual SpecFlowConfiguration LoadConfiguration(SpecFlowConfiguration specFlowConfiguration, SpecFlowConfigurationHolder specFlowConfigurationHolder)
{
return(_configurationLoader.Load(specFlowConfiguration, specFlowConfigurationHolder));
}
