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);
}
protected override void DoExecute()
{
if (DebugTask)
{
System.Diagnostics.Debugger.Launch();
}
ITraceListener traceListener = VerboseOutput ? (ITraceListener) new TextWriterTraceListener(GetMessageWriter(MessageImportance.High), "SpecFlow: ") : new NullListener();
SpecFlowProject specFlowProject = MsBuildProjectReader.LoadSpecFlowProjectFromMsBuild(ProjectPath);
BatchGenerator batchGenerator = new MsBuildBatchGenerator(traceListener, new TestGeneratorFactory(), this);
batchGenerator.OnError +=
delegate(FeatureFileInput featureFileInput, TestGeneratorResult result)
{
foreach (var testGenerationError in result.Errors)
{
RecordError(testGenerationError.Message,
featureFileInput.GetFullPath(specFlowProject.ProjectSettings), testGenerationError.Line, testGenerationError.LinePosition);
}
};
batchGenerator.OnSuccess +=
(featureFileInput, result) => generatedFiles.Add(
new TaskItem(featureFileInput.GetGeneratedTestFullPath(specFlowProject.ProjectSettings)));
batchGenerator.ProcessProject(specFlowProject, ForceGeneration);
}
public static SpecFlowProject ReadSpecFlowProject(string projectPath, SourceAssemblyProbe sourceAssemblyProbe, string defaultNameSpace = null)
{
var specFlowProject = new SpecFlowProject();
specFlowProject.ProjectSettings.ProjectFolder = projectPath;
specFlowProject.ProjectSettings.ProjectName = sourceAssemblyProbe.AssemblyName;
var projectSettings = specFlowProject.ProjectSettings;
projectSettings.AssemblyName = sourceAssemblyProbe.AssemblyName;
projectSettings.DefaultNamespace = defaultNameSpace ?? sourceAssemblyProbe.AssemblyName;
var featureFiles = Directory
.GetFiles(projectPath, "*.feature", SearchOption.AllDirectories)
.Select(file => new FeatureFileInput(file)
{
CustomNamespace = projectSettings.DefaultNamespace +
DirectoryUtils.GetContainingDirectory(file)
.Replace(projectPath, string.Empty)
.Replace(Path.DirectorySeparatorChar, '.')
});
specFlowProject.FeatureFiles.AddRange(featureFiles);
Configure(specFlowProject, sourceAssemblyProbe);
return(specFlowProject);
}
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 GenerateCode(FileProjectItem item, CustomToolContext context)
{
context.RunAsync(
() => {
string fileName = item.FileName;
var projectNode = item.Project;
SpecFlowProject specFlowProject = CreateSpecFlowProjectFrom(projectNode);
var specFlowGenerator = new SpecFlowGenerator(specFlowProject);
string outputFile = context.GetOutputFileName(item, ".feature");
var specFlowFeatureFile = specFlowProject.GetOrCreateFeatureFile(fileName);
var fileContents = File.ReadAllText(fileName);
string outputFileContents;
using (var reader = new StringReader(fileContents)) {
using (var writer = new StringWriter(new StringBuilder())) {
specFlowGenerator.GenerateTestFile(specFlowFeatureFile, projectNode.LanguageProperties.CodeDomProvider, reader, writer);
outputFileContents = writer.ToString();
}
}
File.WriteAllText(outputFile, outputFileContents);
WorkbenchSingleton.SafeThreadCall(
() => context.EnsureOutputFileIsInProject(item, outputFile));
});
}
public void Should_parse_csproj_file_correctly()
{
var directoryName = Path.GetDirectoryName(this.GetType().Assembly.Location);
string projectFilePath = Path.Combine(directoryName, "Data\\sampleCsProjectfile.csproj");
SpecFlowProject specflowProjectfile = MsBuildProjectReader.LoadSpecFlowProjectFromMsBuild(projectFilePath);
specflowProjectfile.FeatureFiles.Count.Should().Be(3);
specflowProjectfile.FeatureFiles.Single(x => x.ProjectRelativePath == @"Features\Login\SocialLogins.feature").Should().NotBeNull();
specflowProjectfile.FeatureFiles.Single(x => x.ProjectRelativePath == @"Features\WorkflowDefinition\CreateWorkflowDefinition.feature").Should().NotBeNull();
specflowProjectfile.FeatureFiles.Single(x => x.ProjectRelativePath == @"Features\WorkflowInstance\WorkflowInstance.feature").Should().NotBeNull();
specflowProjectfile.ProjectSettings.AssemblyName.Should().Be("Hacapp.Web.Tests.UI");
specflowProjectfile.ProjectSettings.DefaultNamespace.Should().Be("Hacapp.Web.Tests.UI");
specflowProjectfile.ProjectSettings.ProjectName.Should().Be("sampleCsProjectfile");
specflowProjectfile.ProjectSettings.ProjectPlatformSettings.Language.Should().Be("C#");
specflowProjectfile.ProjectSettings.ProjectPlatformSettings.LanguageVersion.Should().Be(new Version(3, 0));
specflowProjectfile.ProjectSettings.ProjectPlatformSettings.Platform.Should().Be(".NET");
specflowProjectfile.ProjectSettings.ProjectPlatformSettings.PlatformVersion.Should().Be(new Version(3, 5));
specflowProjectfile.Configuration.GeneratorConfiguration.AllowDebugGeneratedFiles.Should().BeFalse();
specflowProjectfile.Configuration.GeneratorConfiguration.AllowRowTests.Should().BeTrue();
specflowProjectfile.Configuration.GeneratorConfiguration.GeneratorUnitTestProvider.Should().Be("MSTest");
specflowProjectfile.Configuration.GeneratorConfiguration.FeatureLanguage.Name.Should().Be("en-US");
}
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 void ProcessProject(SpecFlowProject specFlowProject, bool forceGenerate)
{
traceListener.WriteToolOutput("Processing project: " + specFlowProject.ProjectSettings.ProjectName);
GenerationSettings generationSettings = GetGenerationSettings(forceGenerate);
using (var generator = CreateGenerator(specFlowProject))
{
foreach (var featureFile in specFlowProject.FeatureFiles)
{
var featureFileInput = CreateFeatureFileInput(featureFile, generator, specFlowProject);
var generationResult = GenerateTestFile(generator, featureFileInput, generationSettings);
if (!generationResult.Success)
{
traceListener.WriteToolOutput("{0} -> test generation failed", featureFile.ProjectRelativePath);
}
else if (generationResult.IsUpToDate)
{
traceListener.WriteToolOutput("{0} -> test up-to-date", featureFile.ProjectRelativePath);
}
else
{
traceListener.WriteToolOutput("{0} -> test updated", featureFile.ProjectRelativePath);
}
}
}
}
private static SpecFlowProject LoadSpecFlowProjectFromDteProjectInternal(Project project)
{
string projectFolder = Path.GetDirectoryName(project.FullName);
SpecFlowProject specFlowProject = new SpecFlowProject();
specFlowProject.ProjectFolder = projectFolder;
specFlowProject.ProjectName = Path.GetFileNameWithoutExtension(project.FullName);
specFlowProject.AssemblyName = project.Properties.Item("AssemblyName").Value as string;
specFlowProject.DefaultNamespace = project.Properties.Item("DefaultNamespace").Value as string;
foreach (ProjectItem projectItem in VsxHelper.GetAllPhysicalFileProjectItem(project))
{
if (".feature".Equals(Path.GetExtension(projectItem.Name), StringComparison.InvariantCultureIgnoreCase))
{
var featureFile = new SpecFlowFeatureFile(VsxHelper.GetProjectRelativePath(projectItem));
var ns = projectItem.Properties.Item("CustomToolNamespace").Value as string;
if (!String.IsNullOrEmpty(ns))
{
featureFile.CustomNamespace = ns;
}
specFlowProject.FeatureFiles.Add(featureFile);
}
}
specFlowProject.Configuration = LoadSpecFlowConfigurationFromDteProjectInternal(project);
return(specFlowProject);
}
public SpecFlowProject ReadSpecFlowProject(string projectFilePath)
{
Microsoft.Build.Evaluation.Project project = ProjectCollection.GlobalProjectCollection.LoadProject(projectFilePath);
string projectFolder = Path.GetDirectoryName(projectFilePath);
var specFlowProject = new SpecFlowProject();
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;
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 void ProcessProject(SpecFlowProject specFlowProject, bool forceGenerate)
{
traceListener.WriteToolOutput("Processing project: " + specFlowProject.ProjectSettings.ProjectName);
GenerationSettings generationSettings = GetGenerationSettings(forceGenerate);
using (var generator = CreateGenerator(specFlowProject))
{
foreach (var featureFile in specFlowProject.FeatureFiles)
{
var featureFileInput = CreateFeatureFileInput(featureFile, generator, specFlowProject);
var generationResult = GenerateTestFile(generator, featureFileInput, generationSettings);
if (!generationResult.Success)
{
traceListener.WriteToolOutput("{0} -> test generation failed", featureFile.ProjectRelativePath);
}
else if (generationResult.IsUpToDate)
{
traceListener.WriteToolOutput("{0} -> test up-to-date", featureFile.ProjectRelativePath);
}
else
{
traceListener.WriteToolOutput("{0} -> test updated", featureFile.ProjectRelativePath);
}
}
}
}
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;
}
/// <summary>
/// Create and return instantiation of a parser represented by RegularExpressionScanner object.
/// </summary>
/// <param name="buffer">An <see cref="IVsTextLines"/> represents lines of source to parse.</param>
/// <returns>Returns a RegularExpressionScanner object</returns>
public override IScanner GetScanner(IVsTextLines buffer)
{
SpecFlowProject specFlowProject = DteProjectReader.LoadSpecFlowProjectFromDteProject(CurrentProject);
scanner = new RegularExpressionScanner(specFlowProject.Configuration.GeneratorConfiguration.FeatureLanguage);
return(scanner);
}
protected override void DoExecute()
{
SpecFlowProject specFlowProject = MsBuildProjectReader.LoadSpecFlowProjectFromMsBuild(ProjectPath);
ITraceListener traceListener = VerboseOutput ? (ITraceListener) new TextWriterTraceListener(GetMessageWriter(MessageImportance.High), "SpecFlow: ") : new NullListener();
BatchGenerator batchGenerator = new MsBuildBatchGenerator(traceListener, new TestGeneratorFactory(), this);
batchGenerator.ProcessProject(specFlowProject, ForceGeneration);
}
protected override void DoExecute()
{
SpecFlowProject specFlowProject = MsBuildProjectReader.LoadSpecFlowProjectFromMsBuild(ProjectPath);
BatchGenerator batchGenerator = new MsBuildBatchGenerator(
GetMessageWriter(MessageImportance.High), VerboseOutput, this);
batchGenerator.ProcessProject(specFlowProject, ForceGeneration);
}
private static IEnumerable <string> GetStepAssemblies(SpecFlowProject specFlowProject)
{
yield return(specFlowProject.ProjectSettings.AssemblyName);
foreach (var stepAssembly in specFlowProject.Configuration.RuntimeConfiguration.AdditionalStepAssemblies)
{
yield return(stepAssembly);
}
}
public static void GenerateAll(
[Required(Description = "Visual Studio Project File containing features")] string projectFile,
[Optional(false, "force", "f")] bool forceGeneration,
[Optional(false, "verbose", "v")] bool verboseOutput)
{
SpecFlowProject specFlowProject = MsBuildProjectReader.LoadSpecFlowProjectFromMsBuild(projectFile);
var batchGenerator = new BatchGenerator(Console.Out, verboseOutput);
batchGenerator.ProcessProject(specFlowProject, forceGeneration);
}
public StepDefinitionReportGenerator(StepDefinitionReportParameters reportParameters)
{
ReportParameters = reportParameters;
specFlowProject = MsBuildProjectReader.LoadSpecFlowProjectFromMsBuild(reportParameters.ProjectFile);
parsedFeatures = ParserHelper.GetParsedFeatures(specFlowProject);
var basePath = Path.Combine(specFlowProject.ProjectSettings.ProjectFolder, reportParameters.BinFolder);
bindings = BindingCollector.CollectBindings(specFlowProject, basePath);
}
public void InitializeProject(string projectPath, string rootNamespace, IEnumerable <string> generatorPlugins)
{
_specFlowProject = MsBuildProjectReader.LoadSpecFlowProjectFromMsBuild(Path.GetFullPath(projectPath), rootNamespace);
var projectSettings = _specFlowProject.ProjectSettings;
var testGeneratorFactory = new TestGeneratorFactory();
_testGenerator = testGeneratorFactory.CreateGenerator(projectSettings, generatorPlugins);
}
public StepDefinitionReportGenerator(StepDefinitionReportParameters reportParameters)
{
ReportParameters = reportParameters;
specFlowProject = MsBuildProjectReader.LoadSpecFlowProjectFromMsBuild(reportParameters.ProjectFile);
parsedSpecFlowDocuments = ParserHelper.GetParsedFeatures(specFlowProject);
var basePath = Path.Combine(specFlowProject.ProjectSettings.ProjectFolder, reportParameters.BinFolder);
bindings = BindingCollector.CollectBindings(specFlowProject, basePath);
}
public static void GenerateAll(
[Required(Description = "Visual Studio Project File containing features")] string projectFile,
[Optional(false, "force", "f")] bool forceGeneration,
[Optional(false, "verbose", "v")] bool verboseOutput)
{
SpecFlowProject specFlowProject = MsBuildProjectReader.LoadSpecFlowProjectFromMsBuild(projectFile);
ITraceListener traceListener = verboseOutput ? (ITraceListener) new TextWriterTraceListener(Console.Out) : new NullListener();
var batchGenerator = new BatchGenerator(traceListener, new TestGeneratorFactory());
batchGenerator.ProcessProject(specFlowProject, forceGeneration);
}
protected virtual ReportElements.NUnitExecutionReport GenerateReport(SpecFlowProject specFlowProject)
{
var report = new ReportElements.NUnitExecutionReport();
report.ProjectName = specFlowProject.ProjectSettings.ProjectName;
report.GeneratedAt = DateTime.Now.ToString("g", CultureInfo.InvariantCulture);
XmlDocument xmlTestResult = LoadXmlTestResult();
report.NUnitXmlTestResult = xmlTestResult.DocumentElement;
ExtendReport(report);
return report;
}
protected virtual ReportElements.NUnitExecutionReport GenerateReport(SpecFlowProject specFlowProject)
{
var report = new ReportElements.NUnitExecutionReport();
report.ProjectName = specFlowProject.ProjectSettings.ProjectName;
report.GeneratedAt = DateTime.Now.ToString("g", CultureInfo.InvariantCulture);
XmlDocument xmlTestResult = LoadXmlTestResult();
report.NUnitXmlTestResult = xmlTestResult.DocumentElement;
ExtendReport(report);
return(report);
}
protected override string GenerateCode(string inputFileContent)
{
CodeDomProvider provider = GetCodeProvider();
SpecFlowProject specFlowProject = DteProjectReader.LoadSpecFlowProjectFromDteProject(CurrentProject);
SpecFlowGenerator generator = new SpecFlowGenerator(specFlowProject);
using (var writer = new StringWriter(new StringBuilder()))
{
generator.GenerateTestFile(
specFlowProject.GetOrCreateFeatureFile(CodeFilePath),
provider, new StringReader(inputFileContent), writer);
return(writer.ToString());
}
}
public bool ProcessProject(SpecFlowProject specFlowProject, bool forceGenerate)
{
traceListener.WriteToolOutput("Processing project: " + specFlowProject.ProjectSettings.ProjectName);
GenerationSettings generationSettings = GetGenerationSettings(forceGenerate);
bool success = true;
using (var generator = CreateGenerator(specFlowProject))
{
traceListener.WriteToolOutput("Using Generator: {0}", generator.GetType().FullName);
foreach (var featureFile in specFlowProject.FeatureFiles)
{
var featureFileInput = CreateFeatureFileInput(featureFile, generator, specFlowProject);
var generationResult = GenerateTestFile(generator, featureFileInput, generationSettings);
if (!generationResult.Success)
{
traceListener.WriteToolOutput("{0} -> test generation failed", featureFile.ProjectRelativePath);
success = false;
if (OnError != null)
{
OnError(featureFile, generationResult);
}
}
else if (generationResult.IsUpToDate)
{
traceListener.WriteToolOutput("{0} -> test up-to-date", featureFile.ProjectRelativePath);
}
else
{
traceListener.WriteToolOutput("{0} -> test updated", featureFile.ProjectRelativePath);
if (OnGenerated != null)
{
OnGenerated(featureFile, generationResult);
}
}
if (generationResult.Success)
{
if (OnSuccess != null)
{
OnSuccess(featureFile, generationResult);
}
}
}
}
return(success);
}
private void TransformReport(ReportElements.NUnitExecutionReport report, SpecFlowProject specFlowProject)
{
XmlSerializer serializer = new XmlSerializer(typeof(ReportElements.NUnitExecutionReport),
ReportElements.NUnitExecutionReport.XmlNamespace);
if (XsltHelper.IsXmlOutput(ReportParameters.OutputFile))
{
XsltHelper.TransformXml(serializer, report, ReportParameters.OutputFile);
}
else
{
XsltHelper.TransformHtml(serializer, report, ReportType,
ReportParameters.OutputFile, specFlowProject.Configuration.GeneratorConfiguration,
ReportParameters.XsltFile);
}
}
public static void GenerateAll(GenerateAllOptions parameters)
{
if (parameters.RequestDebuggerToAttach)
{
Debugger.Launch();
}
ITraceListener traceListener = parameters.VerboseOutput ? (ITraceListener) new TextWriterTraceListener(Console.Out) : new NullListener();
SpecFlowProject specFlowProject = MsBuildProjectReader.LoadSpecFlowProjectFromMsBuild(Path.GetFullPath(parameters.ProjectFile));
var batchGenerator = new BatchGenerator(traceListener, new TestGeneratorFactory());
batchGenerator.OnError += BatchGenerator_OnError;
batchGenerator.ProcessProject(specFlowProject, parameters.ForceGeneration);
}
private void TransformReport(ReportElements.NUnitExecutionReport report, SpecFlowProject specFlowProject)
{
XmlSerializer serializer = new XmlSerializer(typeof(ReportElements.NUnitExecutionReport),
ReportElements.NUnitExecutionReport.XmlNamespace);
if (XsltHelper.IsXmlOutput(ReportParameters.OutputFile))
{
XsltHelper.TransformXml(serializer, report, ReportParameters.OutputFile);
}
else
{
XsltHelper.TransformHtml(serializer, report, ReportType,
ReportParameters.OutputFile, specFlowProject.Configuration.SpecFlowConfiguration,
ReportParameters.XsltFile);
}
}
public static SpecFlowProject CreateSpecFlowProjectFrom(Project project)
{
var specFlowProject = new SpecFlowProject();
specFlowProject.ProjectSettings.ProjectFolder = project.BaseDirectory;
specFlowProject.ProjectSettings.ProjectName = project.Name;
string defaultNamespace = "Namespace";
if (project is DotNetProject)
{
defaultNamespace = ((DotNetProject)project).GetDefaultNamespace(project.Name);
}
// No way to get AssemblyName right now, therefore we'll just use DefaultNamespace
specFlowProject.ProjectSettings.AssemblyName = defaultNamespace;
specFlowProject.ProjectSettings.DefaultNamespace = defaultNamespace;
// TODO: Find out if we really need to add all the feature files everytime we generate
foreach (ProjectFile projectFile in project.Files.Where(IsFeatureOrAppConfigFile))
{
string extension = Path.GetExtension(projectFile.Name);
if (extension.Equals(".feature", StringComparison.InvariantCultureIgnoreCase))
{
string fileName = projectFile.FilePath.ToRelative(project.BaseDirectory);
var featureFile = new FeatureFileInput(fileName);
var customToolNamespace = projectFile.CustomToolNamespace;
if (!String.IsNullOrEmpty(customToolNamespace))
{
featureFile.CustomNamespace = customToolNamespace;
}
specFlowProject.FeatureFiles.Add(featureFile);
}
if (extension.Equals(".config", StringComparison.InvariantCultureIgnoreCase))
{
string configContent = File.ReadAllText(projectFile.FilePath);
GeneratorConfigurationReader.UpdateConfigFromFileContent(specFlowProject.Configuration.GeneratorConfiguration, configContent);
}
}
return(specFlowProject);
}
private FilePath GenerateFeatureCodeFileFor(ProjectFile featureFile)
{
// TODO: We only support C# for now, later we'll add support to grab the provider based on the project
CodeDomProvider codeProvider = new CSharpCodeProvider();
FilePath outputFile = featureFile.FilePath.ChangeExtension(".feature." + codeProvider.FileExtension);
SpecFlowProject specFlowProject = MonoDevelopProjectReader.CreateSpecFlowProjectFrom(featureFile.Project);
var specFlowGenerator = new SpecFlowGenerator(specFlowProject);
using (var writer = new StringWriter(new StringBuilder()))
using (var reader = new StringReader(File.ReadAllText(featureFile.FilePath)))
{
SpecFlowFeatureFile specFlowFeatureFile = specFlowProject.GetOrCreateFeatureFile(featureFile.FilePath);
specFlowGenerator.GenerateTestFile(specFlowFeatureFile, codeProvider, reader, writer);
File.WriteAllText(outputFile, writer.ToString());
}
return(outputFile);
}
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 static void GenerateAll(
[Required(Description = "Visual Studio Project File containing features")] string projectFile,
[Optional(false, "force", "f")] bool forceGeneration,
[Optional(false, "verbose", "v")] bool verboseOutput,
[Optional(false, "debug", Description = "Used for tool integration")] bool requestDebuggerToAttach)
{
if (requestDebuggerToAttach)
{
Debugger.Launch();
}
SpecFlowProject specFlowProject = MsBuildProjectReader.LoadSpecFlowProjectFromMsBuild(Path.GetFullPath(projectFile));
ITraceListener traceListener = verboseOutput ? (ITraceListener) new TextWriterTraceListener(Console.Out) : new NullListener();
var batchGenerator = new BatchGenerator(traceListener, new TestGeneratorFactory());
batchGenerator.OnError += batchGenerator_OnError;
batchGenerator.ProcessProject(specFlowProject, forceGeneration);
}
public static SpecFlowProject CreateSpecFlowProjectFrom(Project project)
{
var specFlowProject = new SpecFlowProject();
specFlowProject.ProjectSettings.ProjectFolder = project.BaseDirectory;
specFlowProject.ProjectSettings.ProjectName = project.Name;
string defaultNamespace = "Namespace";
if (project is DotNetProject)
{
defaultNamespace = ((DotNetProject)project).GetDefaultNamespace(project.Name);
}
// No way to get AssemblyName right now, therefore we'll just use DefaultNamespace
specFlowProject.ProjectSettings.AssemblyName = defaultNamespace;
specFlowProject.ProjectSettings.DefaultNamespace = defaultNamespace;
// TODO: Find out if we really need to add all the feature files everytime we generate
foreach (ProjectFile projectFile in project.Files.Where(IsFeatureOrAppConfigFile))
{
string extension = Path.GetExtension(projectFile.Name);
if (extension.Equals(".feature", StringComparison.InvariantCultureIgnoreCase))
{
string fileName = projectFile.FilePath.ToRelative(project.BaseDirectory);
var featureFile = new FeatureFileInput(fileName);
var customToolNamespace = projectFile.CustomToolNamespace;
if (!String.IsNullOrEmpty(customToolNamespace))
featureFile.CustomNamespace = customToolNamespace;
specFlowProject.FeatureFiles.Add(featureFile);
}
if (extension.Equals(".config", StringComparison.InvariantCultureIgnoreCase))
{
string configContent = File.ReadAllText(projectFile.FilePath);
GeneratorConfigurationReader.UpdateConfigFromFileContent(specFlowProject.Configuration.GeneratorConfiguration, configContent);
}
}
return specFlowProject;
}
public bool ProcessProject(SpecFlowProject specFlowProject, bool forceGenerate)
{
traceListener.WriteToolOutput("Processing project: " + specFlowProject.ProjectSettings.ProjectName);
GenerationSettings generationSettings = GetGenerationSettings(forceGenerate);
bool success = true;
using (var generator = CreateGenerator(specFlowProject))
{
traceListener.WriteToolOutput("Using Generator: {0}", generator.GetType().FullName);
foreach (var featureFile in specFlowProject.FeatureFiles)
{
var featureFileInput = CreateFeatureFileInput(featureFile, generator, specFlowProject);
var generationResult = GenerateTestFile(generator, featureFileInput, generationSettings);
if (!generationResult.Success)
{
traceListener.WriteToolOutput("{0} -> test generation failed", featureFile.ProjectRelativePath);
success = false;
if (OnError != null)
OnError(featureFile, generationResult);
}
else if (generationResult.IsUpToDate)
{
traceListener.WriteToolOutput("{0} -> test up-to-date", featureFile.ProjectRelativePath);
}
else
{
traceListener.WriteToolOutput("{0} -> test updated", featureFile.ProjectRelativePath);
if (OnGenerated != null)
OnGenerated(featureFile, generationResult);
}
if (generationResult.Success)
{
if (OnSuccess != null)
OnSuccess(featureFile, generationResult);
}
}
}
return success;
}
public static SpecFlowProject LoadSpecFlowProjectFromMsBuild(string projectFile)
{
projectFile = Path.GetFullPath(projectFile);
Project project = new Project();
project.Load(projectFile, ProjectLoadSettings.IgnoreMissingImports);
string projectFolder = Path.GetDirectoryName(projectFile);
SpecFlowProject specFlowProject = new SpecFlowProject();
specFlowProject.ProjectFolder = projectFolder;
specFlowProject.ProjectName = Path.GetFileNameWithoutExtension(projectFile);
specFlowProject.AssemblyName = project.GetEvaluatedProperty("AssemblyName");
specFlowProject.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 SpecFlowFeatureFile(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))
{
GeneratorConfigurationReader.UpdateConfigFromFile(specFlowProject.GeneratorConfiguration, Path.Combine(projectFolder, item.FinalItemSpec));
}
}
return(specFlowProject);
}
internal static List <BindingInfo> CollectBindings(SpecFlowProject specFlowProject, string basePath)
{
List <BindingInfo> bindings = new List <BindingInfo>();
var reportingFolder = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
AppDomainSetup appDomainSetup = new AppDomainSetup();
appDomainSetup.ApplicationBase = reportingFolder;
AppDomain appDomain = AppDomain.CreateDomain("CollectBindings", null, appDomainSetup);
AssemblyServices.SubscribeAssemblyResolve(appDomain, basePath);
BindingCollector bindingCollector =
(BindingCollector)appDomain.CreateInstanceAndUnwrap(
Assembly.GetExecutingAssembly().GetName().FullName,
typeof(BindingCollector).FullName);
bindings.AddRange(bindingCollector.CollectBindings(specFlowProject.AssemblyName));
AppDomain.Unload(appDomain);
return(bindings);
}
public void ProcessProject(SpecFlowProject specFlowProject, bool forceGenerate)
{
if (verboseOutput)
{
traceWriter.WriteLine("Processing project: " + specFlowProject);
}
SpecFlowGenerator generator = new SpecFlowGenerator(specFlowProject);
foreach (var featureFile in specFlowProject.FeatureFiles)
{
string featureFileFullPath = featureFile.GetFullPath(specFlowProject);
string codeFileFullPath = featureFileFullPath + ".cs";
bool needsProcessing = true;
if (!forceGenerate && IsUpToDate(generator, featureFileFullPath, codeFileFullPath))
{
needsProcessing = false;
}
if (verboseOutput || needsProcessing)
{
traceWriter.WriteLine("Processing file: {0}", featureFileFullPath);
if (!needsProcessing)
{
traceWriter.WriteLine(" up-to-date");
}
}
if (needsProcessing)
{
GenerateFile(generator, featureFile, codeFileFullPath);
}
}
}
static void Configure(SpecFlowProject specFlowProject, SourceAssemblyProbe sourceAssemblyProbe)
{
const string defaultConfiguration = @"<?xml version=""1.0"" encoding=""utf-8""?>
<configuration>
<configSections>
<section name=""specFlow"" type=""TechTalk.SpecFlow.Configuration.ConfigurationSectionHandler, TechTalk.SpecFlow"" />
</configSections>
<specFlow>
<unitTestProvider name=""SpecRun"" />
<plugins>
<add name=""SpecRun"" />
</plugins>
</specFlow>
</configuration>";
var configurationContent = sourceAssemblyProbe.HasSpecFlowConfigured
? File.ReadAllText(sourceAssemblyProbe.AssemblyPath + ".config")
: defaultConfiguration;
var configurationHolderFromFileContent = GetConfigurationHolderFromContent(configurationContent);
specFlowProject.ProjectSettings.ConfigurationHolder = configurationHolderFromFileContent;
specFlowProject.Configuration = new GeneratorConfigurationProvider().LoadConfiguration(configurationHolderFromFileContent);
}
protected virtual ITestGenerator CreateGenerator(SpecFlowProject specFlowProject)
{
return testGeneratorFactory.CreateGenerator(specFlowProject.ProjectSettings);
}
internal static List<BindingInfo> CollectBindings(SpecFlowProject specFlowProject, string basePath)
{
List<BindingInfo> bindings = new List<BindingInfo>();
var reportingFolder = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
AppDomainSetup appDomainSetup = new AppDomainSetup();
appDomainSetup.ApplicationBase = reportingFolder;
AppDomain appDomain = AppDomain.CreateDomain("CollectBindings", null, appDomainSetup);
AssemblyServices.SubscribeAssemblyResolve(appDomain, basePath);
BindingCollector bindingCollector =
(BindingCollector)appDomain.CreateInstanceAndUnwrap(
Assembly.GetExecutingAssembly().GetName().FullName,
typeof(BindingCollector).FullName);
bindings.AddRange(bindingCollector.CollectBindings(specFlowProject.ProjectSettings.AssemblyName));
AppDomain.Unload(appDomain);
return bindings;
}
public static List<Feature> GetParsedFeatures(SpecFlowProject specFlowProject)
{
return GetParsedFeatures(specFlowProject.FeatureFiles.Select(ff => ff.GetFullPath(specFlowProject.ProjectSettings)),
specFlowProject.Configuration.GeneratorConfiguration.FeatureLanguage);
}
protected virtual ReportElements.NUnitExecutionReport GenerateReport(SpecFlowProject specFlowProject)
{
return GenerateReport(specFlowProject.ProjectSettings.ProjectName);
}
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(".sfeature", 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;
}
public SpecFlowGenerator(SpecFlowProject project)
{
this.project = project;
}
protected virtual FeatureFileInput CreateFeatureFileInput(FeatureFileInput featureFile, ITestGenerator generator, SpecFlowProject specFlowProject)
{
return(featureFile);
}
protected virtual FeatureFileInput CreateFeatureFileInput(FeatureFileInput featureFile, ITestGenerator generator, SpecFlowProject specFlowProject)
{
return featureFile;
}
