public static IObjectContainer CreateContainer(SpecFlowConfigurationHolder configurationHolder, ProjectSettings projectSettings)
{
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);
container.RegisterInstanceAs(projectSettings);
container.RegisterInstanceAs(container.Resolve<CodeDomHelper>(projectSettings.ProjectPlatformSettings.Language));
if (specFlowConfiguration.GeneratorConfiguration.GeneratorUnitTestProvider != null)
container.RegisterInstanceAs(container.Resolve<IUnitTestGeneratorProvider>(specFlowConfiguration.GeneratorConfiguration.GeneratorUnitTestProvider));
return container;
}
private string GenerateTestFromSimpleFeature(ProjectSettings projectSettings)
{
var testGenerator = CreateTestGenerator(projectSettings);
var result = testGenerator.GenerateTestFile(CreateSimpleValidFeatureFileInput(), defaultSettings);
result.Success.Should().Be(true);
return result.GeneratedTestCode;
}
public void Should_report_error_when_unsupported_project_language()
{
ProjectSettings invalidLangSettings = new ProjectSettings { ProjectFolder = Path.GetTempPath(), ProjectPlatformSettings = new ProjectPlatformSettings { Language = "InvalidLang" } };
var testGenerator = CreateTestGenerator(invalidLangSettings);
var result = testGenerator.GenerateTestFile(CreateSimpleValidFeatureFileInput(), defaultSettings);
result.Errors.Should().NotBeNull();
result.Errors.Should().NotBeEmpty();
}
public static string GetFullPath(this FeatureFileInput featureFileInput, ProjectSettings projectSettings)
{
if (featureFileInput == null) throw new ArgumentNullException("featureFileInput");
if (projectSettings == null)
return featureFileInput.ProjectRelativePath;
return Path.GetFullPath(Path.Combine(projectSettings.ProjectFolder, featureFileInput.ProjectRelativePath));
}
public static TextReader GetFeatureFileContentReader(this FeatureFileInput featureFileInput, ProjectSettings projectSettings)
{
if (featureFileInput == null) throw new ArgumentNullException("featureFileInput");
if (featureFileInput.FeatureFileContent != null)
return new StringReader(featureFileInput.FeatureFileContent);
Debug.Assert(projectSettings != null);
return new StreamReader(Path.Combine(projectSettings.ProjectFolder, featureFileInput.ProjectRelativePath));
}
protected TestGenerator CreateTestGenerator(ProjectSettings projectSettings)
{
GeneratorConfiguration generatorConfiguration = new GeneratorConfiguration();
CodeDomHelper codeDomHelper = new CodeDomHelper(CodeDomProviderLanguage.CSharp);
UnitTestFeatureGenerator unitTestFeatureGenerator = new UnitTestFeatureGenerator(new NUnitTestGeneratorProvider(codeDomHelper), codeDomHelper, generatorConfiguration, new DecoratorRegistryStub());
var generatorRegistryStub = new Mock<IFeatureGeneratorRegistry>();
generatorRegistryStub.Setup(r => r.CreateGenerator(It.IsAny<Feature>())).Returns(unitTestFeatureGenerator);
return new TestGenerator(generatorConfiguration, projectSettings, TestHeaderWriterStub.Object, TestUpToDateCheckerStub.Object, generatorRegistryStub.Object, codeDomHelper);
}
private ProjectSettings GetProjectSettingsCached()
{
if (!enableSettingsCache)
return GetProjectSettings();
var result = projectSettings;
if (result == null)
projectSettings = result = GetProjectSettings();
return result;
}
public TestGenerator(GeneratorConfiguration generatorConfiguration, ProjectSettings projectSettings, ITestHeaderWriter testHeaderWriter, ITestUpToDateChecker testUpToDateChecker)
{
if (generatorConfiguration == null) throw new ArgumentNullException("generatorConfiguration");
if (projectSettings == null) throw new ArgumentNullException("projectSettings");
if (testHeaderWriter == null) throw new ArgumentNullException("testHeaderWriter");
if (testUpToDateChecker == null) throw new ArgumentNullException("testUpToDateChecker");
this.generatorConfiguration = generatorConfiguration;
this.testUpToDateChecker = testUpToDateChecker;
this.testHeaderWriter = testHeaderWriter;
this.projectSettings = projectSettings;
}
private TestGeneratorResult GenerateCode(string inputFilePath, string inputFileContent, GeneratorServices generatorServices, ProjectSettings projectSettings)
{
using (var testGenerator = generatorServices.CreateTestGenerator())
{
var fullPath = Path.GetFullPath(Path.Combine(projectSettings.ProjectFolder, inputFilePath));
FeatureFileInput featureFileInput =
new FeatureFileInput(FileSystemHelper.GetRelativePath(fullPath, projectSettings.ProjectFolder))
{
FeatureFileContent = inputFileContent
};
return testGenerator.GenerateTestFile(featureFileInput, new GenerationSettings());
}
}
public TestGenerator(GeneratorConfiguration generatorConfiguration, ProjectSettings projectSettings, ITestHeaderWriter testHeaderWriter, ITestUpToDateChecker testUpToDateChecker, IFeatureGeneratorRegistry featureGeneratorRegistry, CodeDomHelper codeDomHelper)
{
if (generatorConfiguration == null) throw new ArgumentNullException("generatorConfiguration");
if (projectSettings == null) throw new ArgumentNullException("projectSettings");
if (testHeaderWriter == null) throw new ArgumentNullException("testHeaderWriter");
if (testUpToDateChecker == null) throw new ArgumentNullException("testUpToDateChecker");
if (featureGeneratorRegistry == null) throw new ArgumentNullException("featureGeneratorRegistry");
this.generatorConfiguration = generatorConfiguration;
this.testUpToDateChecker = testUpToDateChecker;
this.featureGeneratorRegistry = featureGeneratorRegistry;
this.codeDomHelper = codeDomHelper;
this.testHeaderWriter = testHeaderWriter;
this.projectSettings = projectSettings;
}
public void Should_generate_test_from_feature_file_specified_by_path()
{
using (var tempFile = new TempFile(".feature"))
{
tempFile.SetContent(CreateSimpleValidFeatureFileInput().FeatureFileContent);
ProjectSettings projectSettings = new ProjectSettings { ProjectFolder = tempFile.FolderName, ProjectPlatformSettings = net35CSSettings };
var testGenerator = CreateTestGenerator(projectSettings);
var result = testGenerator.GenerateTestFile(
new FeatureFileInput(tempFile.FileName),
defaultSettings);
result.Success.Should().Be(true);
}
}
private string Generate(string inputFilePath, string inputFileContent, GeneratorServices generatorServices, CodeDomHelper codeDomHelper, ProjectSettings projectSettings)
{
string outputFileContent;
try
{
TestGeneratorResult generationResult = GenerateCode(inputFilePath, inputFileContent, generatorServices, projectSettings);
if (generationResult.Success)
outputFileContent = generationResult.GeneratedTestCode;
else
outputFileContent = GenerateError(generationResult, codeDomHelper);
}
catch (Exception ex)
{
outputFileContent = GenerateError(ex, codeDomHelper);
}
return outputFileContent;
}
public virtual void Setup()
{
net35CSSettings = new ProjectPlatformSettings
{
Language = GenerationTargetLanguage.CSharp,
LanguageVersion = new Version("3.0"),
Platform = GenerationTargetPlatform.DotNet,
PlatformVersion = new Version("3.5"),
};
net35VBSettings = new ProjectPlatformSettings
{
Language = GenerationTargetLanguage.VB,
LanguageVersion = new Version("9.0"),
Platform = GenerationTargetPlatform.DotNet,
PlatformVersion = new Version("3.5"),
};
net35CSProjectSettings = new ProjectSettings { ProjectFolder = Path.GetTempPath(), ProjectPlatformSettings = net35CSSettings };
net35VBProjectSettings = new ProjectSettings { ProjectFolder = Path.GetTempPath(), ProjectPlatformSettings = net35VBSettings };
defaultSettings = new GenerationSettings();
TestHeaderWriterStub = new Mock<ITestHeaderWriter>();
TestUpToDateCheckerStub = new Mock<ITestUpToDateChecker>();
}
protected TestGenerator CreateTestGenerator(ProjectSettings projectSettings)
{
return new TestGenerator(new GeneratorConfiguration(), projectSettings, TestHeaderWriterStub.Object, TestUpToDateCheckerStub.Object);
}
public ITestGenerator CreateGenerator(ProjectSettings projectSettings)
{
EnsureInitialized();
usageCounter.Increase();
var remoteGenerator = remoteTestGeneratorFactory.CreateGenerator(projectSettings);
var disposeNotificationGenerator = new DisposeNotificationTestGenerator(remoteGenerator);
disposeNotificationGenerator.Disposed += () => usageCounter.Decrease();
return disposeNotificationGenerator;
}
public GeneratorPluginLoader(ProjectSettings projectSettings)
{
this.projectSettings = projectSettings;
this.generatorFolder = Path.GetDirectoryName(new Uri(Assembly.GetExecutingAssembly().CodeBase).LocalPath);
}
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().ShouldEqual("DummyGenerator"); // since the type is wrapped, we can only check it this way
}
}
public TestUpToDateChecker(ITestHeaderWriter testHeaderWriter, GeneratorInfo generatorInfo, ProjectSettings projectSettings)
{
this.testHeaderWriter = testHeaderWriter;
this.generatorInfo = generatorInfo;
this.projectSettings = projectSettings;
}
public SeleniumNUnitTestGeneratorProvider(CodeDomHelper codeDomHelper, ProjectSettings projectSettings)
{
this.codeDomHelper = codeDomHelper;
this.projectSettings = projectSettings;
this.customConfigResolver = new CustomConfigResolver();
}
public ITestGenerator CreateGenerator(ProjectSettings projectSettings)
{
var container = GeneratorContainerBuilder.CreateContainer(projectSettings.ConfigurationHolder);
container.RegisterInstanceAs(projectSettings);
return container.Resolve<ITestGenerator>();
}
public virtual void InvalidateSettings()
{
projectSettings = null;
}
public SpecFlowProject()
{
ProjectSettings = new ProjectSettings();
FeatureFiles = new List<FeatureFileInput>();
Configuration = new SpecFlowProjectConfiguration();
}
public void Should_return_detected_version_from_file()
{
Version version = new Version();
TestHeaderWriterStub.Setup(thw => thw.DetectGeneratedTestVersion("any")).Returns(version);
using (var tempFile = new TempFile(".cs"))
{
tempFile.SetContent("any");
ProjectSettings projectSettings = new ProjectSettings { ProjectFolder = tempFile.FolderName, ProjectPlatformSettings = net35CSSettings };
var testGenerator = CreateTestGenerator(projectSettings);
FeatureFileInput featureFileInput = CreateSimpleValidFeatureFileInput();
featureFileInput.GeneratedTestProjectRelativePath = tempFile.FileName;
var result = testGenerator.DetectGeneratedTestVersion(featureFileInput);
result.Should().NotBeNull();
result.Should().Be(version);
}
}
public TestUpToDateChecker(ITestHeaderWriter testHeaderWriter, GeneratorConfiguration generatorConfiguration, ProjectSettings projectSettings)
{
this.testHeaderWriter = testHeaderWriter;
this.projectSettings = projectSettings;
this.generatorConfiguration = generatorConfiguration;
}
/// <summary>
/// Initializes a new instance of the <see cref="SpecBindConfigurationProvider"/> class.
/// </summary>
/// <param name="projectSettings">The project settings.</param>
public SpecBindConfigurationProvider(ProjectSettings projectSettings)
{
this.projectSettings = projectSettings;
}
public void FinalizeTestClass(TestClassGenerationContext generationContext)
{
this.projectSettings = null;
this.enableSauceLabs = false;
this.scenarioSetupMethodsAdded = false;
this.sauceLabSettings = null;
}
