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)); }