private ITestRunnerGateway GetCurrentTestRunnerGateway(Project project)
{
if (VsxHelper.GetReference(project, "TechTalk.SpecRun") != null)
{
return(container.Resolve <ITestRunnerGateway>(TestRunnerTool.SpecRun.ToString()));
}
var reSharperAssembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(a => a.GetName().Name == "JetBrains.ReSharper.UnitTestFramework");
if (reSharperAssembly != null)
{
if (reSharperAssembly.GetName().Version.Major <= 5)
{
return(container.Resolve <ITestRunnerGateway>(TestRunnerTool.ReSharper5.ToString()));
}
return(container.Resolve <ITestRunnerGateway>(TestRunnerTool.ReSharper.ToString()));
}
if (ideIntegration == IdeIntegration.Install.IdeIntegration.VisualStudio2012)
{
return(container.Resolve <ITestRunnerGateway>(TestRunnerTool.VisualStudio2012.ToString()));
}
if (VsxHelper.GetReference(project, "Microsoft.VisualStudio.QualityTools.UnitTestFramework") != null)
{
return(container.Resolve <ITestRunnerGateway>(TestRunnerTool.VisualStudio2010MsTest.ToString()));
}
MessageBox.Show(
"Could not find matching test runner. Please specify the test runner tool in 'Tools / Options / SpecFlow'",
"SpecFlow", MessageBoxButton.OK, MessageBoxImage.Error);
return(null);
}
private void FilesTrackerOnFileChanged(ProjectItem projectItem)
{
if (!IsInitialized)
{
return;
}
bool isInScope = IsMatchingProjectItem(projectItem);
var fileInfo = FindFileInfo(VsxHelper.GetProjectRelativePath(projectItem));
if (fileInfo != null)
{
if (isInScope)
{
ChangeFile(fileInfo);
}
else
{
RemoveFileInfo(fileInfo);
}
}
else if (isInScope)
{
AddFileInfo(projectItem);
}
}
public bool RunTests(Project project, string filter, bool debug)
{
if (!VsxHelper.Build(project))
{
MessageBox.Show("Build failed.",
"SpecFlow",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
return(true);
}
var consolePath = FindConsolePath(project);
if (consolePath == null)
{
MessageBox.Show("Unable to find SpecRun.exe.",
"SpecFlow",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
return(true);
}
var args = BuildCommandArgs(new ConsoleOptions
{
BaseFolder = VsxHelper.GetProjectFolder(project) + @"\bin\Debug", //TODO
Target = VsxHelper.GetProjectAssemblyName(project) + ".dll",
Filter = filter
}, debug);
ExecuteTests(consolePath, args, debug);
return(true);
}
private void ProjectReferencesTrackerOnReferenceChanged(Reference reference)
{
if (!IsInitialized)
{
return;
}
var bindingAsssembly = BindingAssemblies.FirstOrDefault(ba => ba.AssemblyName.Equals(reference.Name, StringComparison.InvariantCultureIgnoreCase));
bool isInScope = bindingAsssembly != null && !bindingAsssembly.IsProject;
var fileInfo = FindFileInfo(VsxHelper.GetProjectRelativePath(reference));
if (fileInfo != null)
{
if (isInScope)
{
ChangeFile(fileInfo);
}
else
{
RemoveFileInfo(fileInfo);
}
}
else if (isInScope)
{
fileInfo = new BindingFileInfo(reference);
AddFileInfo(fileInfo);
}
}
public GenerateStepDefinitionSkeletonForm(string featureTitle, StepInstance[] steps, Project specFlowProject, StepDefinitionSkeletonStyle stepDefinitionSkeletonStyle, ProgrammingLanguage defaultLanguage, DTE dte)
{
this.dte = dte;
InitializeComponent();
stepsList.BeginUpdate();
stepsList.Items.Clear();
foreach (var step in steps)
{
stepsList.Items.Add(new ListItem(step), true);
}
stepsList.EndUpdate();
classNameTextBox.Text = string.Format("{0} Steps", featureTitle).ToIdentifier();
styleComboBox.BeginUpdate();
var styles = Enum.GetValues(typeof(StepDefinitionSkeletonStyle)).Cast <StepDefinitionSkeletonStyle>()
.Where(value => value != StepDefinitionSkeletonStyle.MethodNameRegex || defaultLanguage == ProgrammingLanguage.FSharp)
.ToArray();
styleComboBox.Items.Clear();
styleComboBox.Items.AddRange(styles.Select(s => new StyleItem(s)).ToArray <object>());
int selectedIndex = Array.IndexOf(styles, stepDefinitionSkeletonStyle);
styleComboBox.SelectedIndex = selectedIndex < 0 ? 0 : selectedIndex;
styleComboBox.EndUpdate();
defaultFolder = Path.Combine(VsxHelper.GetProjectFolder(specFlowProject), "StepDefinitions");
if (!Directory.Exists(defaultFolder))
{
var currentFeatureFilePath = dte.ActiveDocument.FullName;
defaultFolder = Path.GetDirectoryName(currentFeatureFilePath);
}
}
private void ProcessBindingsFromProjectItem(ProjectItem projectItem, IdeBindingSourceProcessor bindingSourceProcessor, List <ProjectItem> relatedProjectItems)
{
foreach (CodeClass codeClass in VsxHelper.GetClasses(projectItem))
{
CodeClass2 bindingClassIncludingParts = codeClass as CodeClass2;
var parts = new List <CodeClass>();
if (bindingClassIncludingParts == null)
{
parts.Add(codeClass);
}
else
{
parts.AddRange(bindingClassIncludingParts.Parts.OfType <CodeClass>());
}
var baseClass = codeClass.Bases.OfType <CodeClass>().FirstOrDefault();
while (baseClass != null && baseClass.FullName != "System.Object")
{
tracer.Trace("Adding inherited bindings for class: " + baseClass.FullName, GetType().Name);
parts.Add(baseClass);
baseClass = baseClass.Bases.OfType <CodeClass>().FirstOrDefault();
}
// we need to use the class parts to grab class-related information (e.g. [Binding] attribute)
// but we need to process the binding methods only from the current part, otherwise these
// methods would be registered to multiple file paths, and the update tracking would not work
relatedProjectItems.AddRange(parts.Select(p => p.ProjectItem).Where(pi => pi != null && pi != projectItem));
ProcessCodeClass(codeClass, bindingSourceProcessor, parts.ToArray());
}
}
private bool DetectFromRuntimeReference(GeneratorInfo generatorInfo)
{
var specFlowRef = VsxHelper.GetReference(project, "TechTalk.SpecFlow");
if (specFlowRef == null)
{
return(false);
}
var specFlowRefPath = specFlowRef.Path;
if (string.IsNullOrWhiteSpace(specFlowRefPath))
{
return(false);
}
string runtimeFolder = Path.GetDirectoryName(specFlowRefPath);
if (runtimeFolder == null)
{
return(false);
}
tracer.Trace("Runtime found at " + runtimeFolder, "VsGeneratorInfoProvider");
return(probingPaths.Select(probingPath => Path.GetFullPath(Path.Combine(runtimeFolder, probingPath)))
.Any(probingPath => DetectFromFolder(generatorInfo, probingPath)));
}
public CodeFunction FindCodeFunction(VsProjectScope projectScope, IBindingMethod bindingMethod)
{
var project = projectScope.Project;
var function = FindCodeFunction(project, bindingMethod);
if (function != null)
{
return(function);
}
var specFlowProject = projectScope.SpecFlowProjectConfiguration;
if (specFlowProject != null)
{
foreach (var assemblyName in specFlowProject.RuntimeConfiguration.AdditionalStepAssemblies)
{
string simpleName = assemblyName.Split(new[] { ',' }, 2)[0];
var stepProject = VsxHelper.FindProjectByAssemblyName(project.DTE, simpleName);
if (stepProject != null)
{
function = FindCodeFunction(stepProject, bindingMethod);
if (function != null)
{
return(function);
}
}
}
}
return(null);
}
protected override Func <GeneratorServices> GeneratorServicesProvider(Project project)
{
IVisualStudioTracer tracer = VsxHelper.ResolveMefDependency <IVisualStudioTracer>(ServiceProvider.GlobalProvider);
IntegrationOptionsProvider = VsxHelper.ResolveMefDependency <IIntegrationOptionsProvider>(ServiceProvider.GlobalProvider);
return(() => new VsGeneratorServices(project, new VsSpecFlowConfigurationReader(project, tracer), tracer, IntegrationOptionsProvider));
}
public TValue GetValue <TValue>()
{
if (typeof(TValue) == typeof(string))
{
return((TValue)(object)VsxHelper.ParseCodeStringValue(customAttributeArgument.Value, customAttributeArgument.Language));
}
throw new NotSupportedException();
}
protected override void Analyze(FeatureFileInfo featureFileInfo, ProjectItem projectItem)
{
vsProjectScope.VisualStudioTracer.Trace("Analyzing feature file: " + featureFileInfo.ProjectRelativePath, "ProjectFeatureFilesTracker");
AnalyzeCodeBehind(featureFileInfo, projectItem);
var fileContent = VsxHelper.GetFileContent(projectItem, loadLastSaved: true);
featureFileInfo.ParsedFeature = ParseGherkinFile(fileContent, featureFileInfo.ProjectRelativePath, vsProjectScope.GherkinDialectServices.DefaultLanguage);
}
public FeatureFileInfo(ProjectItem projectItem, ProjectItem codeBehindItem)
{
ProjectRelativePath = VsxHelper.GetProjectRelativePath(projectItem);
var codeBehindItemChangeDate = VsxHelper.GetLastChangeDate(codeBehindItem) ?? DateTime.MinValue;
var featureFileLastChangeDate = VsxHelper.GetLastChangeDate(projectItem) ?? DateTime.MinValue;
LastChangeDate = featureFileLastChangeDate > codeBehindItemChangeDate ? featureFileLastChangeDate : codeBehindItemChangeDate;
}
private void GetCompletionsFromProject(Project project, ScenarioBlock scenarioBlock, List <Completion> result)
{
foreach (ProjectItem projectItem in VsxHelper.GetAllProjectItem(project).Where(pi => pi.FileCodeModel != null))
{
FileCodeModel codeModel = projectItem.FileCodeModel;
GetCompletitionsFromCodeElements(codeModel.CodeElements, scenarioBlock, result);
}
}
public bool RunScenario(ProjectItem projectItem, IScenarioBlock currentScenario, ScenarioOutlineExamplesRow examplesRow, IGherkinFileScope fileScope, bool debug)
{
var line = currentScenario.KeywordLine;
if (examplesRow != null && examplesRow.BlockRelativeLine >= 0)
{
line += examplesRow.BlockRelativeLine;
}
return(RunInCurrentContext(VsxHelper.GetFileName(projectItem), debug, line));
}
private void AnalyzeCodeBehind(FeatureFileInfo featureFileInfo, ProjectItem projectItem)
{
var codeBehindItem = GetCodeBehindItem(projectItem);
if (codeBehindItem != null)
{
string codeBehind = VsxHelper.GetFileContent(codeBehindItem);
featureFileInfo.GeneratorVersion = SpecFlowGenerator.GetGeneratedFileSpecFlowVersion(new StringReader(codeBehind));
}
}
private void ReGenerate(FeatureFileInfo featureFileInfo)
{
var projectItem = VsxHelper.FindProjectItemByProjectRelativePath(vsProjectScope.Project, featureFileInfo.ProjectRelativePath);
if (projectItem != null)
{
VSProjectItem vsProjectItem = projectItem.Object as VSProjectItem;
if (vsProjectItem != null)
vsProjectItem.RunCustomTool();
}
}
protected override string GetConfigFileContent()
{
ProjectItem projectItem = VsxHelper.FindProjectItemByProjectRelativePath(project, "app.config");
if (projectItem == null)
{
return(null);
}
return(VsxHelper.GetFileContent(projectItem, true));
}
private string GetStringArgumentValue(CodeAttribute2 codeAttribute, string argumentName)
{
var arg = codeAttribute.Arguments.Cast <CodeAttributeArgument>().FirstOrDefault(a => a.Name == argumentName);
if (arg == null)
{
return(null);
}
return(VsxHelper.ParseCodeStringValue(arg.Value, arg.Language));
}
public bool RunFeatures(ProjectItem projectItem, bool debug)
{
var fileName = VsxHelper.GetFileName(projectItem);
if (fileName != null && fileName.EndsWith(".feature", StringComparison.InvariantCultureIgnoreCase))
{
return(RunFromCodeBehind(projectItem, GetFeatureCodeBehindLine, debug));
}
return(RunInCurrentContext(debug));
}
private ProjectItem FindProjectItemByProjectRelativePath(TFileInfo fileInfo)
{
try
{
return(GetProjects().Select(project => VsxHelper.FindProjectItemByProjectRelativePath(project, fileInfo.ProjectRelativePath)).FirstOrDefault(pi => pi != null));
}
catch (Exception)
{
return(null);
}
}
private GherkinLanguageService CreateLanguageService(ITextBuffer textBuffer)
{
var project = VsxHelper.GetCurrentProject(textBuffer, AdaptersFactory, ServiceProvider);
var projectScope = ProjectScopeFactory.GetProjectScope(project);
var languageService = new GherkinLanguageService(projectScope, VisualStudioTracer, enableStepMatchColoring: IntegrationOptionsProvider.GetOptions().EnableStepMatchColoring);
textBuffer.Changed +=
(sender, args) => languageService.TextBufferChanged(GetTextBufferChange(args));
return(languageService);
}
public bool RunFeatures(ProjectItem projectItem, bool debug)
{
var fileName = VsxHelper.GetFileName(projectItem);
if (fileName != null && fileName.EndsWith(".feature", StringComparison.InvariantCultureIgnoreCase))
{
return(RunInCurrentContext(fileName, debug));
}
return(RunCommand(debug ? "TestExplorer.DebugAllTestsInContext" : "TestExplorer.RunAllTestsInContext"));
}
protected override void Analyze(FeatureFileInfo featureFileInfo, ProjectItem projectItem)
{
vsProjectScope.Tracer.Trace("Analyzing feature file: " + featureFileInfo.ProjectRelativePath, "ProjectFeatureFilesTracker");
var codeBehindChangeDate = AnalyzeCodeBehind(featureFileInfo, projectItem);
var fileContent = VsxHelper.GetFileContent(projectItem, loadLastSaved: true);
featureFileInfo.ParsedFeature = ParseGherkinFile(fileContent, featureFileInfo.ProjectRelativePath, vsProjectScope.GherkinDialectServices.DefaultLanguage);
var featureLastChangeDate = VsxHelper.GetLastChangeDate(projectItem) ?? DateTime.MinValue;
featureFileInfo.LastChangeDate = featureLastChangeDate > codeBehindChangeDate ? featureLastChangeDate : codeBehindChangeDate;
}
public virtual void RegisterDefaults(IObjectContainer container)
{
var serviceProvider = container.Resolve <IServiceProvider>();
RegisterVsDependencies(container, serviceProvider);
RegisterDependencies(container);
container.RegisterInstanceAs <IIdeTracer>(VsxHelper.ResolveMefDependency <IVisualStudioTracer>(serviceProvider));
container.RegisterInstanceAs(VsxHelper.ResolveMefDependency <IProjectScopeFactory>(serviceProvider));
RegisterCommands(container);
}
private ProjectItem FindProjectItemByProjectRelativePath(TFileInfo fileInfo)
{
try
{
return(GetProjects().Select(project => VsxHelper.FindProjectItemByProjectRelativePath(project, fileInfo.ProjectRelativePath)).FirstOrDefault(pi => pi != null));
}
catch (Exception exception)
{
vsProjectScope.Tracer.Trace("Exception: " + exception.ToString(), GetType().Name);
return(null);
}
}
private IEnumerable <CodeClass> GetBindingClassesIncludingPartialClasses(Project project)
{
foreach (CodeClass bindingClassWithBindingAttribute in VsxHelper.GetClasses(project).Where(IsBindingClass))
{
yield return(bindingClassWithBindingAttribute);
CodeClass2 bindingClassIncludingParts = bindingClassWithBindingAttribute as CodeClass2;
foreach (CodeClass2 currentBindingPartialClass in bindingClassIncludingParts.Parts)
{
yield return(currentBindingPartialClass as CodeClass);
}
}
}
public static GherkinEditorContext FromDocument(Document document, IGherkinLanguageServiceFactory gherkinLanguageServiceFactory)
{
var textView = VsxHelper.GetWpfTextView(VsxHelper.GetIVsTextView(document));
if (textView == null)
{
return(null);
}
var languageService = gherkinLanguageServiceFactory.GetLanguageService(textView.TextBuffer);
return(new GherkinEditorContext(languageService, textView));
}
protected override void BeforeQueryStatus(OleMenuCommand command, SelectedItems selection)
{
base.BeforeQueryStatus(command, selection);
if (command.Visible)
{
var selectedItem = selection.Item(1);
if (selectedItem.ProjectItem != null && VsxHelper.IsPhysicalFile(selectedItem.ProjectItem) && !ContextDependentNavigationCommand.IsFeatureFile(selectedItem.ProjectItem))
{
command.Visible = false; //only show it in feature file, folder or project nodes
}
}
}
private GherkinLanguageService CreateLanguageService(ITextBuffer textBuffer)
{
var project = VsxHelper.GetCurrentProject(textBuffer, AdaptersFactory, ServiceProvider);
var projectScope = ProjectScopeFactory.GetProjectScope(project);
var languageService = new GherkinLanguageService(projectScope, VisualStudioTracer);
textBuffer.Changed +=
(sender, args) => languageService.TextBufferChanged(GetTextBufferChange(args));
languageService.Initialize(textBuffer);
return(languageService);
}
protected virtual void RegisterVsDependencies(IObjectContainer container, IServiceProvider serviceProvider)
{
var dte = serviceProvider.GetService(typeof(DTE)) as DTE;
if (dte != null)
{
container.RegisterInstanceAs(dte);
container.RegisterInstanceAs((DTE2)dte);
}
container.RegisterInstanceAs(VsxHelper.ResolveMefDependency <IOutputWindowService>(serviceProvider));
container.RegisterInstanceAs(VsxHelper.ResolveMefDependency <IGherkinLanguageServiceFactory>(serviceProvider));
}
