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