public void Check_Plugins_PluginType_Runtime()
{
string config = @"<specflow><plugins><add name=""testEntry"" type=""Runtime""/></plugins></specflow>";
var configSection = ConfigurationSectionHandler.CreateFromXml(config);
var runtimeConfig = new AppConfigConfigurationLoader().LoadAppConfig(ConfigurationLoader.GetDefault(), configSection);
runtimeConfig.Plugins.Count.Should().Be(1);
runtimeConfig.Plugins.First().Type.Should().Be(PluginType.Runtime);
}
public void Check_StepAssemblies_OneEntry()
{
string config = @"<specflow><stepAssemblies><stepAssembly assembly=""testEntry""/></stepAssemblies></specflow>";
var configSection = ConfigurationSectionHandler.CreateFromXml(config);
var runtimeConfig = new AppConfigConfigurationLoader().LoadAppConfig(ConfigurationLoader.GetDefault(), configSection);
runtimeConfig.AdditionalStepAssemblies.Count.Should().Be(1);
runtimeConfig.AdditionalStepAssemblies.First().Should().Be("testEntry");
}
public void Check_Plugins_PluginPath()
{
string config = @"<specflow><plugins><add name=""testEntry"" path=""path_to_assembly""/></plugins></specflow>";
var configSection = ConfigurationSectionHandler.CreateFromXml(config);
var runtimeConfig = new AppConfigConfigurationLoader().LoadAppConfig(ConfigurationLoader.GetDefault(), configSection);
runtimeConfig.Plugins.Count.Should().Be(1);
runtimeConfig.Plugins.First().Path.Should().Be("path_to_assembly");
}
public void CanLoadConfigWithParallelCodeGenerationOptionsFromString(string configString)
{
var generatorConfiguration = new GeneratorConfiguration();
generatorConfiguration.UpdateFromConfigFile(ConfigurationSectionHandler.CreateFromXml(configString));
Assert.IsTrue(generatorConfiguration.MarkFeaturesParallelizable);
Assert.IsNotEmpty(generatorConfiguration.SkipParallelizableMarkerForTags);
Assert.Contains("mySpecialTag1", generatorConfiguration.SkipParallelizableMarkerForTags);
Assert.Contains("mySpecialTag2", generatorConfiguration.SkipParallelizableMarkerForTags);
}
public void CanLoadConfigFromString(string configString)
{
var runtimeConfig = ConfigurationLoader.GetDefault();
var configurationLoader = new AppConfigConfigurationLoader();
var configurationSectionHandler = ConfigurationSectionHandler.CreateFromXml(configString);
configurationLoader.LoadAppConfig(runtimeConfig, configurationSectionHandler);
}
public void Check_CucumberMessages_NotConfigured_EnabledIsFalse()
{
string config = @"<specflow>
</specflow>";
var configSection = ConfigurationSectionHandler.CreateFromXml(config);
var runtimeConfig = new AppConfigConfigurationLoader().LoadAppConfig(ConfigurationLoader.GetDefault(), configSection);
runtimeConfig.CucumberMessagesConfiguration.Enabled.Should().BeFalse();
}
public void Check_Plugins_TwoSameNameEntry()
{
string config = @"<specflow><plugins>
<add name=""testEntry""/>
<add name=""testEntry""/>
</plugins></specflow>";
var configSection = ConfigurationSectionHandler.CreateFromXml(config);
var runtimeConfig = new AppConfigConfigurationLoader().LoadAppConfig(ConfigurationLoader.GetDefault(), configSection);
runtimeConfig.Plugins.Count.Should().Be(1);
runtimeConfig.Plugins[0].Name.Should().Be("testEntry");
}
public void Check_CucumberMessages_Sinks_EmptyList()
{
string config = @"<specflow>
<cucumber-messages enabled=""false"">
<sinks>
</sinks>
</cucumber-messages>
</specflow>";
var configSection = ConfigurationSectionHandler.CreateFromXml(config);
var runtimeConfig = new AppConfigConfigurationLoader().LoadAppConfig(ConfigurationLoader.GetDefault(), configSection);
runtimeConfig.CucumberMessagesConfiguration.Sinks.Should().BeEmpty();
}
private ConfigurationSectionHandler GetSection()
{
XmlDocument configDocument = new XmlDocument();
configDocument.LoadXml(configFileContent);
var specFlowNode = configDocument.SelectSingleNode("/configuration/specFlow");
if (specFlowNode == null)
{
throw new InvalidOperationException("invalid config file content");
}
return(ConfigurationSectionHandler.CreateFromXml(specFlowNode));
}
public void Check_Trace_Listener()
{
string config = @"<specflow><trace listener=""TraceListener"" /></specflow>";
var configSection = ConfigurationSectionHandler.CreateFromXml(config);
var runtimeConfig = new AppConfigConfigurationLoader().LoadAppConfig(ConfigurationLoader.GetDefault(), configSection);
runtimeConfig.CustomDependencies.Count.Should().Be(1);
foreach (ContainerRegistrationConfigElement containerRegistrationConfigElement in runtimeConfig.CustomDependencies)
{
containerRegistrationConfigElement.Implementation.Should().Be("TraceListener");
}
}
public void AddFromXmlSpecFlowSection(string specFlowSection)
{
ProjectBuilder project = _solutionDriver.DefaultProject;
var configSection = ConfigurationSectionHandler.CreateFromXml(specFlowSection);
var appConfigConfigurationLoader = new AppConfigConfigurationLoader();
var specFlowConfiguration = appConfigConfigurationLoader.LoadAppConfig(ConfigurationLoader.GetDefault(), configSection);
foreach (string stepAssemblyName in specFlowConfiguration.AdditionalStepAssemblies)
{
_configurationDriver.AddStepAssembly(new StepAssembly(stepAssemblyName));
}
_configurationDriver.SetBindingCulture(project, specFlowConfiguration.BindingCulture);
_configurationDriver.SetFeatureLanguage(project, specFlowConfiguration.FeatureLanguage);
}
public void Check_CucumberMessages_Sinks_ListOneEntry()
{
string config = @"<specflow>
<cucumber-messages enabled=""false"">
<sinks>
<sink type=""file"" path=""C:\temp\testrun.cm"" />
</sinks>
</cucumber-messages>
</specflow>";
var configSection = ConfigurationSectionHandler.CreateFromXml(config);
var runtimeConfig = new AppConfigConfigurationLoader().LoadAppConfig(ConfigurationLoader.GetDefault(), configSection);
runtimeConfig.CucumberMessagesConfiguration.Sinks.Count.Should().Be(1);
}
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 SpecFlowConfiguration Load(SpecFlowConfiguration specFlowConfiguration, IConfigurationHolder configurationHolder)
{
switch (configurationHolder.ConfigSource)
{
case ConfigSource.AppConfig:
return(LoadAppConfig(specFlowConfiguration,
ConfigurationSectionHandler.CreateFromXml(configurationHolder.Content)));
case ConfigSource.Json:
return(LoadJson(specFlowConfiguration, configurationHolder.Content));
case ConfigSource.Default:
return(GetDefault());
default:
throw new ArgumentOutOfRangeException();
}
}
public void CanLoadConfigWithParallelCodeGenerationOptionsFromString(string configString)
{
var specFlowConfiguration = ConfigurationLoader.GetDefault();
var configurationLoader = new AppConfigConfigurationLoader();
var configurationSectionHandler = ConfigurationSectionHandler.CreateFromXml(configString);
specFlowConfiguration = configurationLoader.LoadAppConfig(specFlowConfiguration, configurationSectionHandler);
Assert.IsTrue(specFlowConfiguration.MarkFeaturesParallelizable);
Assert.IsNotEmpty(specFlowConfiguration.SkipParallelizableMarkerForTags);
Assert.Contains("mySpecialTag1", specFlowConfiguration.SkipParallelizableMarkerForTags);
Assert.Contains("mySpecialTag2", specFlowConfiguration.SkipParallelizableMarkerForTags);
}
/// <summary>
/// Gets the configuration section.
/// </summary>
/// <returns>The located configuration section, otherwise <c>null</c>.</returns>
private ConfigurationSectionHandler GetConfigurationSection()
{
// Reflect content for now
WriteLine("Project Folder: {0}", this.projectSettings != null ? this.projectSettings.ProjectFolder : "NONE");
if (this.projectSettings == null || string.IsNullOrEmpty(this.projectSettings.ProjectFolder))
{
return(null);
}
var directory = new DirectoryInfo(this.projectSettings.ProjectFolder);
var file = directory.GetFiles("app.config", SearchOption.TopDirectoryOnly).FirstOrDefault();
if (file == null)
{
WriteLine(@"Cannot find app.config in directory: {0}", directory.FullName);
return(null);
}
WriteLine("Found Configuration File: {0}", file.FullName);
string content;
using (var streamReader = file.OpenText())
{
content = streamReader.ReadToEnd();
}
var configDocument = new XmlDocument();
configDocument.LoadXml(content);
var node = configDocument.SelectSingleNode("/configuration/specBind");
if (node == null)
{
WriteLine("Could not locate specBind configuration node");
return(null);
}
var xml = node.OuterXml;
WriteLine("Creating configuration from XML: {0}", xml);
return(ConfigurationSectionHandler.CreateFromXml(xml));
}
public void CanLoadConfigWithNonParallelizableTagsProvided()
{
var config =
@"<specFlow>
<generator>
<addNonParallelizableMarkerForTags>
<tag value=""tag1""/>
<tag value=""tag2""/>
</addNonParallelizableMarkerForTags>
</generator>
</specFlow>";
var specFlowConfiguration = ConfigurationLoader.GetDefault();
var configurationLoader = new AppConfigConfigurationLoader();
var configurationSectionHandler = ConfigurationSectionHandler.CreateFromXml(config);
specFlowConfiguration = configurationLoader.LoadAppConfig(specFlowConfiguration, configurationSectionHandler);
specFlowConfiguration.AddNonParallelizableMarkerForTags.Should().BeEquivalentTo("tag1", "tag2");
}
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 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 SpecFlowConfiguration Load(SpecFlowConfiguration specFlowConfiguration)
{
if (_configFilePath == null)
{
return(LoadDefaultConfiguration(specFlowConfiguration));
}
var extension = Path.GetExtension(_configFilePath);
var configFileContent = File.ReadAllText(_configFilePath);
switch (extension.ToLowerInvariant())
{
case ".config":
{
var configDocument = new XmlDocument();
configDocument.LoadXml(configFileContent);
var specFlowNode = configDocument.SelectSingleNode("/configuration/specFlow");
if (specFlowNode == null)
{
return(LoadDefaultConfiguration(specFlowConfiguration));
}
var configSection = ConfigurationSectionHandler.CreateFromXml(specFlowNode);
var loader = new AppConfigConfigurationLoader();
return(loader.LoadAppConfig(specFlowConfiguration, configSection));
}
case ".json":
{
if (_jsonSpecFlow2Mode)
{
configFileContent = ConvertToJsonSpecFlow2Style(configFileContent);
}
var loader = new JsonConfigurationLoader();
return(loader.LoadJson(specFlowConfiguration, configFileContent));
}
}
throw new ConfigurationErrorsException($"Invalid config type: {_configFilePath}");
}