public void AddFeatureFile(string featureFileText)
{
var featureFile = new FeatureFileInput(GetFeatureFileName(), featureFileText);
FeatureFiles.Add(featureFile);
CurrentFeatureFile = featureFile;
}
public override bool Execute()
{
var generateFeatureFileCodeBehindTaskContainerBuilder = new GenerateFeatureFileCodeBehindTaskContainerBuilder();
var generatorPlugins = GeneratorPlugins?.Select(gp => gp.ItemSpec).Select(p => new GeneratorPluginInfo(p)).ToArray() ?? Array.Empty <GeneratorPluginInfo>();
var featureFiles = FeatureFiles?.Select(i => i.ItemSpec).ToArray() ?? Array.Empty <string>();
var msbuildInformationProvider = new MSBuildInformationProvider(MSBuildVersion);
var generateFeatureFileCodeBehindTaskConfiguration = new GenerateFeatureFileCodeBehindTaskConfiguration(AnalyticsTransmitter, CodeBehindGenerator);
var generateFeatureFileCodeBehindTaskInfo = new SpecFlowProjectInfo(generatorPlugins, featureFiles, ProjectPath, ProjectFolder, ProjectGuid, AssemblyName, OutputPath, RootNamespace, TargetFrameworks, TargetFramework);
using (var taskRootContainer = generateFeatureFileCodeBehindTaskContainerBuilder.BuildRootContainer(Log, generateFeatureFileCodeBehindTaskInfo, msbuildInformationProvider, generateFeatureFileCodeBehindTaskConfiguration))
{
var assemblyResolveLoggerFactory = taskRootContainer.Resolve <IAssemblyResolveLoggerFactory>();
using (assemblyResolveLoggerFactory.Build())
{
var taskExecutor = taskRootContainer.Resolve <IGenerateFeatureFileCodeBehindTaskExecutor>();
var executeResult = taskExecutor.Execute();
if (!(executeResult is ISuccess <IReadOnlyCollection <ITaskItem> > success))
{
return(false);
}
GeneratedFiles = success.Result.ToArray();
return(true);
}
}
}
private IEnumerable <string> GenerateFilesForProject()
{
var generator = new FeatureFileCodeBehindGenerator();
var generatorPlugins = GeneratorPlugins?.Select(gp => gp.ItemSpec).ToList() ?? new List <string>();
return(generator.GenerateFilesForProject(ProjectPath, RootNamespace, FeatureFiles.Select(i => i.ItemSpec).ToList(), generatorPlugins, ProjectFolder, OutputPath));
}
public void AddFeatureFile(string featureFileText, string featureFileName = null)
{
featureFileName = featureFileName ?? GetFeatureFileName();
var featureFile = new FeatureFileInput(featureFileName, featureFileText);
FeatureFiles.Add(featureFile);
CurrentFeatureFile = featureFile;
}
public SpecFlowFeatureFile GetOrCreateFeatureFile(string featureFileName)
{
featureFileName = Path.GetFullPath(Path.Combine(ProjectFolder, featureFileName));
var result = FeatureFiles.Find(ff => ff.GetFullPath(this).Equals(featureFileName, StringComparison.InvariantCultureIgnoreCase));
if (result == null)
{
result = new SpecFlowFeatureFile(featureFileName); //TODO: make it project relative
}
return(result);
}
private void GetFeatureFiles()
{
var featureFiles = Directory.GetFiles(DirectoryName, "*.feature");
SquashLogger.Info($"Got {featureFiles.Length} feature files for {DirectoryName}");
foreach (var file in featureFiles)
{
var feature = new SquashFeature(file);
FeatureFiles.Add(feature);
}
}
protected virtual void ScanExistingProjectFolder()
{
FeatureFiles.AddRange(Directory.GetFiles(_options.TargetFolder, "*.feature", SearchOption.AllDirectories));
var projectFilePath = Directory.GetFiles(TargetFolder, "*.csproj").FirstOrDefault();
if (projectFilePath == null)
{
throw new Exception("Unable to detect project file");
}
var projectChanger = CreateProjectChanger(projectFilePath);
InstalledNuGetPackages.AddRange(projectChanger.GetInstalledNuGetPackages(GetPackagesFolder()));
}
private IEnumerable <string> GenerateFilesForProject()
{
var generatorPlugins = GeneratorPlugins?.Select(gp => gp.ItemSpec).ToList() ?? new List <string>();
string taskAssemblyPath = new Uri(this.GetType().GetTypeInfo().Assembly.CodeBase).LocalPath;
var ctxt = new CustomAssemblyLoader();
Assembly inContextAssembly = ctxt.LoadFromAssemblyPath(taskAssemblyPath);
Type innerTaskType = inContextAssembly.GetType(typeof(FeatureFileCodeBehindGenerator).FullName);
object innerTask = Activator.CreateInstance(innerTaskType);
var executeInnerMethod = innerTaskType.GetMethod("GenerateFilesForProject", BindingFlags.Instance | BindingFlags.Public);
var parameters = new object[] { ProjectPath, RootNamespace, FeatureFiles.Select(i => i.ItemSpec).ToList(), generatorPlugins, ProjectFolder, OutputPath };
var result = (IEnumerable <string>)executeInnerMethod.Invoke(innerTask, parameters);
return(result);
}
private void GenerateTestArtifacts(string projectFilePath)
{
var customTool = _options.SpecFlowVersion >= new Version("3.0") ? null : "SpecFlowSingleFileGenerator";
var featuresFolder = Path.Combine(_options.TargetFolder, "Features");
var stepDefsFolder = Path.Combine(_options.TargetFolder, "StepDefinitions");
EnsureEmptyFolder(featuresFolder);
EnsureEmptyFolder(stepDefsFolder);
var stepCount = _options.FeatureFileCount * _options.ScenarioPerFeatureFileCount * 4;
var assetGenerator = new SpecFlowAssetGenerator(Math.Max(3, stepCount * _options.StepDefinitionPerStepPercent / 100));
if (_options.AddUnicodeBinding)
{
assetGenerator.AddUnicodeSteps();
}
if (_options.AddAsyncStep)
{
assetGenerator.AddAsyncStep();
}
var projectChanger = CreateProjectChanger(projectFilePath);
for (int i = 0; i < _options.FeatureFileCount; i++)
{
var scenarioOutlineCount =
_options.ScenarioPerFeatureFileCount * _options.ScenarioOutlinePerScenarioPercent / 100;
var scenarioCount = _options.ScenarioPerFeatureFileCount - scenarioOutlineCount;
var filePath = assetGenerator.GenerateFeatureFile(featuresFolder, scenarioCount, scenarioOutlineCount);
projectChanger.AddFile(filePath, "None", customTool);
FeatureFiles.Add(filePath);
}
var stepDefClasses = assetGenerator.GenerateStepDefClasses(stepDefsFolder, _options.StepDefPerClassCount);
foreach (var stepDefClass in stepDefClasses)
{
projectChanger.AddFile(stepDefClass, "Compile");
}
projectChanger.Save();
_consoleWriteLine(
$"Generated {assetGenerator.StepDefCount} step definitions, {_options.FeatureFileCount * _options.ScenarioPerFeatureFileCount} scenarios, {assetGenerator.StepCount} steps, {stepDefClasses.Count} step definition classes, {_options.FeatureFileCount} feature files");
}
public override bool Execute()
{
try
{
try
{
var currentProcess = Process.GetCurrentProcess();
Log.LogWithNameTag(Log.LogMessage, $"process: {currentProcess.ProcessName}, pid: {currentProcess.Id}, CD: {Environment.CurrentDirectory}");
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
Log.LogWithNameTag(Log.LogMessage, " " + assembly.FullName);
}
}
catch (Exception e)
{
Log.LogWithNameTag(Log.LogMessage, $"Error when dumping process info: {e}");
}
AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;
var generateFeatureFileCodeBehind = new GenerateFeatureFileCodeBehind();
Log.LogWithNameTag(Log.LogMessage, "Starting GenerateFeatureFileCodeBehind");
var generatedFiles = new List <ITaskItem>();
var generatorPlugins = GeneratorPlugins?.Select(gp => gp.ItemSpec).ToList() ?? new List <string>();
var featureFiles = FeatureFiles.Select(i => i.ItemSpec).ToList();
foreach (string s in generateFeatureFileCodeBehind.GenerateFilesForProject(generatorPlugins, ProjectPath, ProjectFolder, OutputPath, RootNamespace, featureFiles))
{
generatedFiles.Add(new TaskItem()
{
ItemSpec = s
});
}
GeneratedFiles = generatedFiles.ToArray();
return(true);
}
catch (Exception e)
{
if (e.InnerException != null)
{
if (e.InnerException is FileLoadException fle)
{
Log?.LogWithNameTag(Log.LogError, $"FileLoadException Filename: {fle.FileName}");
Log?.LogWithNameTag(Log.LogError, $"FileLoadException FusionLog: {fle.FusionLog}");
Log?.LogWithNameTag(Log.LogError, $"FileLoadException Message: {fle.Message}");
}
Log?.LogWithNameTag(Log.LogError, e.InnerException.ToString());
}
Log?.LogWithNameTag(Log.LogError, e.ToString());
return(false);
}
finally
{
AppDomain.CurrentDomain.AssemblyResolve -= CurrentDomain_AssemblyResolve;
}
}
public override bool Execute()
{
try
{
try
{
var currentProcess = Process.GetCurrentProcess();
Log.LogWithNameTag(Log.LogMessage, $"process: {currentProcess.ProcessName}, pid: {currentProcess.Id}, CD: {Environment.CurrentDirectory}");
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
Log.LogWithNameTag(Log.LogMessage, " " + assembly.FullName);
}
}
catch (Exception e)
{
Log.LogWithNameTag(Log.LogMessage, $"Error when dumping process info: {e}");
}
AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;
Log.LogWithNameTag(Log.LogMessage, "Starting GenerateFeatureFileCodeBehind");
var generatorPlugins = GeneratorPlugins?.Select(gp => gp.ItemSpec).ToList() ?? new List <string>();
var featureFiles = FeatureFiles?.Select(i => i.ItemSpec).ToList() ?? new List <string>();
var specFlowProject = MsBuildProjectReader.LoadSpecFlowProjectFromMsBuild(Path.GetFullPath(ProjectPath), RootNamespace);
using (var container = GeneratorContainerBuilder.CreateContainer(specFlowProject.ProjectSettings.ConfigurationHolder, specFlowProject.ProjectSettings, generatorPlugins))
{
RegisterGenerationAndAnalyticsSpecific(container);
GeneratedFiles = GenerateCodeBehindFilesForProject(container, featureFiles);
TransmitProjectCompilingEvent(container);
}
return(!Log.HasLoggedErrors);
}
catch (Exception e)
{
if (e.InnerException != null)
{
if (e.InnerException is FileLoadException fle)
{
Log?.LogWithNameTag(Log.LogError, $"FileLoadException Filename: {fle.FileName}");
Log?.LogWithNameTag(Log.LogError, $"FileLoadException FusionLog: {fle.FusionLog}");
Log?.LogWithNameTag(Log.LogError, $"FileLoadException Message: {fle.Message}");
}
Log?.LogWithNameTag(Log.LogError, e.InnerException.ToString());
}
Log?.LogWithNameTag(Log.LogError, e.ToString());
return(false);
}
finally
{
AppDomain.CurrentDomain.AssemblyResolve -= CurrentDomain_AssemblyResolve;
}
}
