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);
}
private void GenerateTestFile(SpecFlowFeatureFile featureFile, CodeDomProvider codeProvider, TextWriter outputWriter)
{
using (var reader = new StreamReader(featureFile.GetFullPath(project)))
{
GenerateTestFile(featureFile, codeProvider, reader, outputWriter);
}
}
private string GetTargetNamespace(SpecFlowFeatureFile featureFile)
{
if (!string.IsNullOrEmpty(featureFile.CustomNamespace))
{
return(featureFile.CustomNamespace);
}
if (string.IsNullOrEmpty(project.DefaultNamespace))
{
return(null);
}
string targetNamespace = project.DefaultNamespace;
string projectFolder = project.ProjectFolder;
string sourceFileFolder = Path.GetDirectoryName(featureFile.GetFullPath(project));
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);
}
protected virtual void GenerateFile(SpecFlowGenerator generator, SpecFlowFeatureFile featureFile, string codeFileFullPath)
{
using (var writer = GetWriter(codeFileFullPath))
{
generator.GenerateCSharpTestFile(featureFile, writer);
}
}
public static SpecFlowProject LoadSpecFlowProjectFromDteProject(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 GetAllProjectItem(project).Where(IsPhysicalFile))
{
var fileName = GetRelativePath(GetFileName(projectItem), projectFolder);
var extension = Path.GetExtension(fileName);
if (extension.Equals(".feature", StringComparison.InvariantCultureIgnoreCase))
{
var featureFile = new SpecFlowFeatureFile(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.GeneratorConfiguration, GetFileContent(projectItem));
}
}
return(specFlowProject);
}
protected override void GenerateFile(SpecFlowGenerator generator, SpecFlowFeatureFile featureFile, string codeFileFullPath)
{
try
{
base.GenerateFile(generator, featureFile, codeFileFullPath);
outputFile.Done(task.Errors);
}
catch (Exception ex)
{
task.RecordException(ex);
}
finally
{
outputFile = null;
}
}
public CodeNamespace GenerateTestFileCode(SpecFlowFeatureFile featureFile, TextReader inputReader, CodeDomProvider codeProvider, CodeDomHelper codeDomHelper)
{
string targetNamespace = GetTargetNamespace(featureFile);
SpecFlowLangParser parser = new SpecFlowLangParser(project.GeneratorConfiguration.FeatureLanguage);
Feature feature = parser.Parse(inputReader, featureFile.GetFullPath(project));
IUnitTestGeneratorProvider generatorProvider = ConfigurationServices.CreateInstance <IUnitTestGeneratorProvider>(project.GeneratorConfiguration.GeneratorUnitTestProviderType);
codeDomHelper.InjectIfRequired(generatorProvider);
ISpecFlowUnitTestConverter testConverter = new SpecFlowUnitTestConverter(generatorProvider, codeDomHelper, project.GeneratorConfiguration.AllowDebugGeneratedFiles, project.GeneratorConfiguration.AllowRowTests);
var codeNamespace = testConverter.GenerateUnitTestFixture(feature, null, targetNamespace);
return(codeNamespace);
}
public void GenerateTestFile(SpecFlowFeatureFile featureFile, CodeDomProvider codeProvider, TextReader inputReader, TextWriter outputWriter)
{
outputWriter = new HackedWriter(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 static SpecFlowProject CreateSpecFlowProjectFrom(Project project)
{
var specFlowProject = new SpecFlowProject();
specFlowProject.ProjectFolder = project.BaseDirectory;
specFlowProject.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.AssemblyName = defaultNamespace;
specFlowProject.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 SpecFlowFeatureFile(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.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 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);
}
public void GenerateCSharpTestFile(SpecFlowFeatureFile featureFile, TextWriter outputWriter)
{
var codeProvider = new CSharpCodeProvider();
GenerateTestFile(featureFile, codeProvider, outputWriter);
}
