public void AddFeatureFile(string featureFileText)
{
var featureFile = new FeatureFileInput(GetFeatureFileName(), featureFileText);
FeatureFiles.Add(featureFile);
CurrentFeatureFile = featureFile;
}
public TestGeneratorResult GenerateTestFile(FeatureFileInput featureFileInput, GenerationSettings settings)
{
if (featureFileInput == null)
{
throw new ArgumentNullException("featureFileInput");
}
if (settings == null)
{
throw new ArgumentNullException("settings");
}
try
{
return(GenerateTestFileWithExceptions(featureFileInput, settings));
}
catch (ParserException parserException)
{
return(new TestGeneratorResult(parserException.GetParserExceptions().Select(
ex => new TestGenerationError(ex.Location == null ? 0 : ex.Location.Line, ex.Location == null ? 0 : ex.Location.Column, ex.Message))));
}
catch (Exception exception)
{
return(new TestGeneratorResult(new TestGenerationError(exception)));
}
}
protected string GetGeneratedTestCode(FeatureFileInput featureFileInput)
{
using (var outputWriter = new IndentProcessingWriter(new StringWriter()))
{
var codeProvider = codeDomHelper.CreateCodeDomProvider();
var codeNamespace = GenerateTestFileCode(featureFileInput);
if (codeNamespace == null)
{
return("");
}
var options = new CodeGeneratorOptions
{
BracingStyle = "C",
};
AddSpecFlowHeader(codeProvider, outputWriter);
codeProvider.GenerateCodeFromNamespace(codeNamespace, outputWriter, options);
AddSpecFlowFooter(codeProvider, outputWriter);
outputWriter.Flush();
var generatedTestCode = outputWriter.ToString();
return(FixVBNetGlobalNamespace(generatedTestCode));
}
}
SpecFlowDocument GenerateTestFileCode(FeatureFileInput featureFileInput)
{
var parser = _gherkinParserFactory.Create(_generatorConfiguration.FeatureLanguage);
using (var contentReader = featureFileInput.GetFeatureFileContentReader(_projectSettings))
return(parser.Parse(contentReader, featureFileInput.GetFullPath(_projectSettings)));
}
public string Generate(string projectFolder, string configFilePath, string targetExtension, string featureFilePath, string targetNamespace, string projectDefaultNamespace, bool saveResultToFile)
{
using (var generator = CreateGenerator(projectFolder, configFilePath, targetExtension, projectDefaultNamespace))
{
var featureFileInput =
new FeatureFileInput(FileSystemHelper.GetRelativePath(featureFilePath, projectFolder))
{
CustomNamespace = targetNamespace
};
var generationSettings = new GenerationSettings
{
CheckUpToDate = false,
WriteResultToFile = saveResultToFile
};
var result = generator.GenerateTestFile(featureFileInput, generationSettings);
var connectorResult = new GenerationResult();
if (result.Success)
{
connectorResult.FeatureFileCodeBehind = new FeatureFileCodeBehind
{
FeatureFilePath = featureFilePath,
Content = result.GeneratedTestCode
};
}
else
{
connectorResult.ErrorMessage =
string.Join(Environment.NewLine, result.Errors.Select(e => e.Message));
}
var resultJson = JsonSerialization.SerializeObject(connectorResult);
return(resultJson);
}
}
public static string GetGeneratedTestContent(this FeatureFileInput featureFileInput, string generatedTestFullPath)
{
var generatedTestFileContent = featureFileInput.GeneratedTestFileContent;
if (generatedTestFileContent != null)
{
return(generatedTestFileContent);
}
if (generatedTestFullPath == null)
{
return(null);
}
try
{
if (!File.Exists(generatedTestFullPath))
{
return(null);
}
return(File.ReadAllText(generatedTestFullPath));
}
catch (Exception exception)
{
Debug.WriteLine(exception, "FeatureFileInputExtensions.GetGeneratedTestContent");
return(null);
}
}
private void GenerateTestFile(FeatureFileInput featureFile, CodeDomProvider codeProvider, TextWriter outputWriter)
{
using (var reader = new StreamReader(featureFile.GetFullPath(project.ProjectSettings)))
{
GenerateTestFile(featureFile, codeProvider, reader, outputWriter);
}
}
public void Should_be_able_generate_from_a_simple_valid_feature()
{
using (var remoteFactory = CreateRemoteAppDomainTestGeneratorFactory())
{
var generator = remoteFactory.CreateGenerator(new ProjectSettings()
{
ProjectFolder = Path.GetTempPath()
});
FeatureFileInput featureFileInput = new FeatureFileInput("Test.feature")
{
FeatureFileContent = @"
Feature: Addition
@mytag
Scenario: Add two numbers
Given I have entered 50 into the calculator
And I have entered 70 into the calculator
When I press add
Then the result should be 120 on the screen
"
};
var result = generator.GenerateTestFile(featureFileInput, new GenerationSettings());
result.Should().NotBeNull();
result.Success.Should().BeTrue();
result.GeneratedTestCode.Should().NotBeNull();
}
}
public Version DetectGeneratedTestVersion(FeatureFileInput featureFileInput)
{
if (!_integrationOptions.LegacyEnableSpecFlowSingleFileGeneratorCustomTool)
{
return(null);
}
var featureFileInputFile = WriteTempFile(featureFileInput);
var result = _outOfProcessExecutor.Execute(new DetectGeneratedTestVersionParameters()
{
FeatureFile = featureFileInputFile,
Debug = Debugger.IsAttached
}, false);
if (result.ExitCode > 0)
{
throw new Exception(result.Output);
}
return(Version.Parse(result.Output));
}
private SpecFlowProject CreateSpecFlowProjectFrom(IProject project)
{
var specFlowProject = new SpecFlowProject();
specFlowProject.ProjectSettings.ProjectFolder = project.Directory;
specFlowProject.ProjectSettings.ProjectName = project.Name;
specFlowProject.ProjectSettings.AssemblyName = project.AssemblyName;
specFlowProject.ProjectSettings.DefaultNamespace = project.RootNamespace;
var generatorConfig = specFlowProject.Configuration.GeneratorConfiguration;
foreach (var projectFile in project.Items.OfType <FileProjectItem>().Where(IsFeatureOrAppConfigFile))
{
string extension = Path.GetExtension(projectFile.FileName);
if (extension != null && extension.Equals(".feature", StringComparison.InvariantCultureIgnoreCase))
{
string fileName = FileUtilities.GetRelativePath(projectFile.FileName, project.Directory);
var featureFile = new FeatureFileInput(fileName);
specFlowProject.FeatureFiles.Add(featureFile);
}
if (extension != null && extension.Equals(".config", StringComparison.InvariantCultureIgnoreCase))
{
string configContent = File.ReadAllText(projectFile.FileName);
GeneratorConfigurationReader.UpdateConfigFromFileContent(generatorConfig, configContent);
}
}
return(specFlowProject);
}
public void Should_be_able_generate_from_a_simple_invalid_feature()
{
using (var remoteFactory = CreateRemoteAppDomainTestGeneratorFactory())
{
var generator = remoteFactory.CreateGenerator(new ProjectSettings()
{
ProjectFolder = Path.GetTempPath()
});
FeatureFileInput featureFileInput = new FeatureFileInput("Test.feature")
{
FeatureFileContent = @"
Feature: Addition
Scenario: Add two numbers
Given I have entered 50 into the calculator
AndXXX the keyword is misspelled
"
};
var result = generator.GenerateTestFile(featureFileInput, new GenerationSettings());
result.Should().NotBeNull();
result.Success.Should().BeFalse();
result.Errors.Should().NotBeNull();
result.Errors.Should().NotBeEmpty();
}
}
public TestGeneratorResult GenerateTestFile(FeatureFileInput featureFileInput, GenerationSettings settings)
{
if (featureFileInput == null)
{
throw new ArgumentNullException("featureFileInput");
}
if (settings == null)
{
throw new ArgumentNullException("settings");
}
try
{
return(GenerateTestFileWithExceptions(featureFileInput, settings));
}
catch (SpecFlowParserException parserException)
{
if (parserException.ErrorDetails == null || parserException.ErrorDetails.Count == 0)
{
return(new TestGeneratorResult(new TestGenerationError(parserException)));
}
return(new TestGeneratorResult(parserException.ErrorDetails.Select(
ed => new TestGenerationError(ed.ForcedLine - 1, ed.ForcedColumn - 1, ed.Message))));
}
catch (Exception exception)
{
return(new TestGeneratorResult(new TestGenerationError(exception)));
}
}
public static SpecFlowProject LoadSpecFlowProjectFromDteProject(Project project)
{
string projectFolder = Path.GetDirectoryName(project.FullName);
SpecFlowProject specFlowProject = new SpecFlowProject();
specFlowProject.ProjectSettings.ProjectFolder = projectFolder;
specFlowProject.ProjectSettings.ProjectName = Path.GetFileNameWithoutExtension(project.FullName);
specFlowProject.ProjectSettings.AssemblyName = project.Properties.Item("AssemblyName").Value as string;
specFlowProject.ProjectSettings.DefaultNamespace = project.Properties.Item("DefaultNamespace").Value as string;
foreach (ProjectItem projectItem in GetAllProjectItem(project).Where(IsPhysicalFile))
{
var fileName = GetRelativePath(GetFileName(projectItem), projectFolder);
var extension = Path.GetExtension(fileName);
if (extension.Equals(".feature", StringComparison.InvariantCultureIgnoreCase))
{
var featureFile = new FeatureFileInput(fileName);
var ns = projectItem.Properties.Item("CustomToolNamespace").Value as string;
if (!String.IsNullOrEmpty(ns))
{
featureFile.CustomNamespace = ns;
}
specFlowProject.FeatureFiles.Add(featureFile);
}
if (Path.GetFileName(fileName).Equals("app.config", StringComparison.InvariantCultureIgnoreCase))
{
GeneratorConfigurationReader.UpdateConfigFromFileContent(specFlowProject.Configuration.GeneratorConfiguration, GetFileContent(projectItem));
}
}
return(specFlowProject);
}
private string GetTargetNamespace(FeatureFileInput featureFile)
{
if (!string.IsNullOrEmpty(featureFile.CustomNamespace))
{
return(featureFile.CustomNamespace);
}
if (string.IsNullOrEmpty(project.ProjectSettings.DefaultNamespace))
{
return(null);
}
string targetNamespace = project.ProjectSettings.DefaultNamespace;
string projectFolder = project.ProjectSettings.ProjectFolder;
string sourceFileFolder = Path.GetDirectoryName(featureFile.GetFullPath(project.ProjectSettings));
if (sourceFileFolder.StartsWith(sourceFileFolder, StringComparison.InvariantCultureIgnoreCase))
{
string extraFolders = sourceFileFolder.Substring(projectFolder.Length);
if (extraFolders.Length > 0)
{
string[] parts = extraFolders.TrimStart('\\').Split('\\');
targetNamespace += "." + string.Join(".",
parts.Select(p => p.ToIdentifier()).ToArray());
}
}
return(targetNamespace);
}
public TestFileGeneratorResult GenerateCodeBehindFile(string featureFile)
{
var featureFileInput = new FeatureFileInput(featureFile);
var generatedFeatureFileName = Path.GetFileName(_testGenerator.GetTestFullPath(featureFileInput));
var testGeneratorResult = _testGenerator.GenerateTestFile(featureFileInput, new GenerationSettings());
return(new TestFileGeneratorResult(testGeneratorResult, generatedFeatureFileName));
}
protected override FeatureFileInput CreateFeatureFileInput(FeatureFileInput featureFile, ITestGenerator generator, SpecFlowProject specFlowProject)
{
var featureFileInput = base.CreateFeatureFileInput(featureFile, generator, specFlowProject);
outputFile = task.PrepareOutputFile(generator.GetTestFullPath(featureFileInput));
featureFileInput.GeneratedTestProjectRelativePath =
FileSystemHelper.GetRelativePath(outputFile.FilePathForWriting, specFlowProject.ProjectSettings.ProjectFolder);
return(featureFileInput);
}
private FeatureFileInput CreateFeatureFileInput(string file, XElement customNamespace)
{
var featureFile = new FeatureFileInput(file);
if (customNamespace != null)
{
featureFile.CustomNamespace = customNamespace.Value;
}
return(featureFile);
}
private IEnumerable <FeatureFileInput> GetFeatureFiles(XDocument xDocument, bool newProjectSystem, string projectFolder)
{
var nodesWhereFeatureFilesCouldBe = GetNotCompileableNodes(xDocument, newProjectSystem);
var result = new List <FeatureFileInput>();
foreach (var xElement in nodesWhereFeatureFilesCouldBe)
{
var include = xElement.Attribute("Include")?.Value;
var update = xElement.Attribute("Update")?.Value;
if (string.IsNullOrWhiteSpace(include) && string.IsNullOrWhiteSpace(update))
{
continue;
}
var fileName = string.IsNullOrWhiteSpace(update) ? include : update;
if (IsAFeatureFile(fileName))
{
var featureFile = new FeatureFileInput(fileName);
var customNamespace = xElement.Descendants(GetNameWithNamespace("CustomToolNamespace", newProjectSystem)).SingleOrDefault();
if (customNamespace != null)
{
featureFile.CustomNamespace = customNamespace.Value;
}
result.Add(featureFile);
}
}
if (newProjectSystem)
{
var allFilesInProjectFolder = Directory.EnumerateFiles(projectFolder, "*", SearchOption.AllDirectories);
foreach (var file in allFilesInProjectFolder)
{
if (IsAFeatureFile(Path.GetFileName(file)))
{
if (result.Any(i => file.EndsWith(i.ProjectRelativePath)))
{
continue;
}
var realtivePath = file.Replace(projectFolder, "").Trim('\\');
result.Add(new FeatureFileInput(realtivePath));
}
}
}
return(result);
}
public string GetTestFullPath(FeatureFileInput featureFileInput)
{
var path = featureFileInput.GetGeneratedTestFullPath(projectSettings);
if (path != null)
{
return(path);
}
return(featureFileInput.GetFullPath(projectSettings) + GenerationTargetLanguage.GetExtension(projectSettings.ProjectPlatformSettings.Language));
}
public void Should_return_unknown_version_when_there_is_an_error()
{
TestHeaderWriterStub.Setup(thw => thw.DetectGeneratedTestVersion("any")).Throws(new Exception());
var testGenerator = CreateTestGenerator();
FeatureFileInput featureFileInput = CreateSimpleValidFeatureFileInput();
featureFileInput.GeneratedTestFileContent = "any";
var result = testGenerator.DetectGeneratedTestVersion(featureFileInput);
result.Should().Be(null);
}
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 SpecFlowProject ReadSpecFlowProject(string projectFilePath)
{
var specFlowProject = new SpecFlowProject();
Microsoft.Build.Evaluation.Project project = null;
string projectFolder = Path.GetDirectoryName(projectFilePath);
try
{
var reader = XmlReader.Create(projectFilePath);
project = ProjectCollection.GlobalProjectCollection.LoadProject(reader);
specFlowProject.ProjectSettings.ProjectFolder = projectFolder;
specFlowProject.ProjectSettings.ProjectName = Path.GetFileNameWithoutExtension(projectFilePath);
specFlowProject.ProjectSettings.AssemblyName = project.AllEvaluatedProperties.First(x => x.Name == "AssemblyName").EvaluatedValue;
specFlowProject.ProjectSettings.DefaultNamespace = project.AllEvaluatedProperties.First(x => x.Name == "RootNamespace").EvaluatedValue;
}
catch (Exception ex)
{
Debug.WriteLine(ex, "Project load error");
return(new SpecFlowProject());
}
specFlowProject.ProjectSettings.ProjectPlatformSettings.Language = GetLanguage(project);
foreach (ProjectItem item in project.FeatureFiles())
{
var featureFile = new FeatureFileInput(item.EvaluatedInclude);
var ns = item.GetMetadataValue("CustomToolNamespace");
if (!String.IsNullOrEmpty(ns))
{
featureFile.CustomNamespace = ns;
}
specFlowProject.FeatureFiles.Add(featureFile);
}
ProjectItem appConfigItem = project.ApplicationConfigurationFile();
if (appConfigItem != null)
{
var configFilePath = Path.Combine(projectFolder, appConfigItem.EvaluatedInclude);
var configFileContent = File.ReadAllText(configFilePath);
var configurationHolder = GetConfigurationHolderFromFileContent(configFileContent);
specFlowProject.ProjectSettings.ConfigurationHolder = configurationHolder;
specFlowProject.Configuration = configurationLoader.LoadConfiguration(configurationHolder);
}
return(specFlowProject);
}
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 TestGeneratorResult GenerateTestFile(FeatureFileInput featureFileInput, GenerationSettings settings)
{
string projectSettingsFile = WriteTempFile(_projectSettings);
var featureFileInputFile = WriteTempFile(featureFileInput);
var result = _outOfProcessExecutor.Execute(new GenerateTestFileParameters()
{
FeatureFile = featureFileInputFile,
ProjectSettingsFile = projectSettingsFile,
Debug = Debugger.IsAttached,
}, true);
return(new TestGeneratorResult(result.Output, true));
}
public SpecFlowProject ReadSpecFlowProject(IProjectReference projectReference)
{
var projectFilePath = FileProjectReference.AssertFileProjectReference(projectReference).ProjectFilePath;
var project = Engine.GlobalEngine.GetLoadedProject(projectFilePath);
if (project == null)
{
project = new Microsoft.Build.BuildEngine.Project();
project.Load(projectFilePath, ProjectLoadSettings.IgnoreMissingImports);
}
string projectFolder = Path.GetDirectoryName(projectFilePath);
SpecFlowProject specFlowProject = new SpecFlowProject();
specFlowProject.ProjectSettings.ProjectFolder = projectFolder;
specFlowProject.ProjectSettings.ProjectName = Path.GetFileNameWithoutExtension(projectFilePath);
specFlowProject.ProjectSettings.AssemblyName = project.GetEvaluatedProperty("AssemblyName");
specFlowProject.ProjectSettings.DefaultNamespace = project.GetEvaluatedProperty("RootNamespace");
var items = project.GetEvaluatedItemsByName("None").Cast <BuildItem>()
.Concat(project.GetEvaluatedItemsByName("Content").Cast <BuildItem>());
foreach (BuildItem item in items)
{
var extension = Path.GetExtension(item.FinalItemSpec);
if (extension.Equals(".feature", StringComparison.InvariantCultureIgnoreCase))
{
var featureFile = new FeatureFileInput(item.FinalItemSpec);
var ns = item.GetEvaluatedMetadata("CustomToolNamespace");
if (!String.IsNullOrEmpty(ns))
{
featureFile.CustomNamespace = ns;
}
specFlowProject.FeatureFiles.Add(featureFile);
}
if (Path.GetFileName(item.FinalItemSpec).Equals("app.config", StringComparison.InvariantCultureIgnoreCase))
{
var configFilePath = Path.Combine(projectFolder, item.FinalItemSpec);
var configFileContent = File.ReadAllText(configFilePath);
var configurationHolder = GetConfigurationHolderFromFileContent(configFileContent);
specFlowProject.ProjectSettings.ConfigurationHolder = configurationHolder;
specFlowProject.Configuration = configurationLoader.LoadConfiguration(configurationHolder, projectReference);
}
}
return(specFlowProject);
}
public void Should_return_detected_version()
{
Version version = new Version();
TestHeaderWriterStub.Setup(thw => thw.DetectGeneratedTestVersion("any")).Returns(version);
var testGenerator = CreateTestGenerator();
FeatureFileInput featureFileInput = CreateSimpleValidFeatureFileInput();
featureFileInput.GeneratedTestFileContent = "any";
var result = testGenerator.DetectGeneratedTestVersion(featureFileInput);
result.Should().NotBeNull();
result.Should().Be(version);
}
public bool?IsUpToDatePreliminary(FeatureFileInput featureFileInput, string generatedTestFullPath, UpToDateCheckingMethod upToDateCheckingMethod)
{
bool byUpdateTimeCheckResult = IsUpToDateByModificationTimeAndGeneratorVersion(featureFileInput, generatedTestFullPath);
if (upToDateCheckingMethod == UpToDateCheckingMethod.ModificationTimeAndGeneratorVersion)
{
return(byUpdateTimeCheckResult);
}
if (byUpdateTimeCheckResult == false)
{
return(false);
}
return(null);
}
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)));
}
public void GenerateTestFile(FeatureFileInput featureFile, CodeDomProvider codeProvider, TextReader inputReader, TextWriter outputWriter)
{
outputWriter = new IndentProcessingWriter(outputWriter);
CodeDomHelper codeDomHelper = new CodeDomHelper(codeProvider);
var codeNamespace = GenerateTestFileCode(featureFile, inputReader, codeProvider, codeDomHelper);
var options = new CodeGeneratorOptions
{
BracingStyle = "C"
};
AddSpecFlowHeader(codeProvider, outputWriter, codeDomHelper);
codeProvider.GenerateCodeFromNamespace(codeNamespace, outputWriter, options);
AddSpecFlowFooter(codeProvider, outputWriter, codeDomHelper);
outputWriter.Flush();
}
public CodeNamespace GenerateTestFileCode(FeatureFileInput featureFile, TextReader inputReader, CodeDomProvider codeProvider, CodeDomHelper codeDomHelper)
{
string targetNamespace = GetTargetNamespace(featureFile);
SpecFlowLangParser parser = new SpecFlowLangParser(project.Configuration.GeneratorConfiguration.FeatureLanguage);
Feature feature = parser.Parse(inputReader, featureFile.GetFullPath(project.ProjectSettings));
IUnitTestGeneratorProvider generatorProvider = ConfigurationServices.CreateInstance <IUnitTestGeneratorProvider>(project.Configuration.GeneratorConfiguration.GeneratorUnitTestProviderType);
codeDomHelper.InjectIfRequired(generatorProvider);
ISpecFlowUnitTestConverter testConverter = new SpecFlowUnitTestConverter(generatorProvider, codeDomHelper, project.Configuration.GeneratorConfiguration);
var codeNamespace = testConverter.GenerateUnitTestFixture(feature, null, targetNamespace);
return(codeNamespace);
}
