public async Task WhenDiagnosticsRulesAreUpdated_ThenReAnalyzerFilesInProject() { using (var host = GetHost()) { var testFile = new TestFile("testFile_4.cs", "class _this_is_invalid_test_class_name { int n = true; }"); var testAnalyzerRef = new TestAnalyzerReference("TS1101", isEnabledByDefault: false); var projectId = AddProjectWitFile(host, testFile, testAnalyzerRef); var testRulesOriginal = CreateRules(testAnalyzerRef.Id.ToString(), ReportDiagnostic.Error); host.Workspace.UpdateDiagnosticOptionsForProject(projectId, testRulesOriginal.ToImmutableDictionary()); await host.RequestCodeCheckAsync("testFile_4.cs"); var testRulesUpdated = CreateRules(testAnalyzerRef.Id.ToString(), ReportDiagnostic.Suppress); var workspaceUpdatedCheck = new AutoResetEvent(false); host.Workspace.WorkspaceChanged += (_, e) => { if (e.Kind == WorkspaceChangeKind.ProjectChanged) { workspaceUpdatedCheck.Set(); } }; host.Workspace.UpdateDiagnosticOptionsForProject(projectId, testRulesUpdated.ToImmutableDictionary()); Assert.True(workspaceUpdatedCheck.WaitOne(timeout: TimeSpan.FromSeconds(15))); var result = await host.RequestCodeCheckAsync("testFile_4.cs"); Assert.DoesNotContain(result.QuickFixes, f => f.Text.Contains(testAnalyzerRef.Id.ToString())); } }
// This is important because hidden still allows code fixes to execute, not prevents it, for this reason suppressed analytics should not be returned at all. public async Task When_custom_rule_is_set_to_none_dont_return_results_at_all() { using (var host = GetHost()) { var testFile = new TestFile("testFile_3.cs", "class _this_is_invalid_test_class_name { int n = true; }"); var ruleService = host.GetExport <RulesetsForProjects>(); var testAnalyzerRef = new TestAnalyzerReference("TS1101"); var projectIds = AddProjectWitFile(host, testFile, testAnalyzerRef); var testRules = CreateRules(testAnalyzerRef.Id.ToString(), ReportDiagnostic.Suppress); ruleService.AddOrUpdateRuleset(projectIds.Single(), new RuleSet( "", new ReportDiagnostic(), testRules.ToImmutableDictionary(), new ImmutableArray <RuleSetInclude>())); var result = await host.RequestCodeCheckAsync("testFile_3.cs"); Assert.DoesNotContain(result.QuickFixes, f => f.Text.Contains(testAnalyzerRef.Id.ToString())); } }
public async Task WhenDocumentIsntOpenAndAnalyzeOpenDocumentsOnlyIsSet_DontAnalyzeFiles(bool analyzeOpenDocumentsOnly, bool isDocumentOpen) { using (var host = GetHost(analyzeOpenDocumentsOnly)) { var testFile = new TestFile("testFile.cs", "class _this_is_invalid_test_class_name { int n = true; }"); var testAnalyzerRef = new TestAnalyzerReference("TS1100"); AddProjectWithFile(host, testFile, testAnalyzerRef); if (isDocumentOpen) { var doc = host.Workspace.GetDocument("testFile.cs"); host.Workspace.OpenDocument(doc.Id); } var expectedDiagnosticCount = analyzeOpenDocumentsOnly && !isDocumentOpen ? 1 : 2; var result = await host.RequestCodeCheckAsync("testFile.cs"); if (analyzeOpenDocumentsOnly && !isDocumentOpen) { Assert.DoesNotContain(result.QuickFixes.OfType <DiagnosticLocation>(), f => f.Id == testAnalyzerRef.Id.ToString()); } else { Assert.Contains(result.QuickFixes.OfType <DiagnosticLocation>(), f => f.Id == testAnalyzerRef.Id.ToString()); } Assert.Contains(result.QuickFixes.OfType <DiagnosticLocation>(), f => f.Id == "CS0029"); } }
public void Create_AnalyzerReferences() { var version = VersionStamp.Default; var analyzerReference = new TestAnalyzerReference(); var info1 = ProjectInfo.Create( ProjectId.CreateNewId(), version, "proj", "assembly", "C#", analyzerReferences: new[] { analyzerReference } ); Assert.Same( analyzerReference, ((ImmutableArray <AnalyzerReference>)info1.AnalyzerReferences).Single() ); var info2 = ProjectInfo.Create( ProjectId.CreateNewId(), version, "proj", "assembly", "C#" ); Assert.True(((ImmutableArray <AnalyzerReference>)info2.AnalyzerReferences).IsEmpty); var info3 = ProjectInfo.Create( ProjectId.CreateNewId(), version, "proj", "assembly", "C#", analyzerReferences: new AnalyzerReference[0] ); Assert.True(((ImmutableArray <AnalyzerReference>)info3.AnalyzerReferences).IsEmpty); var info4 = ProjectInfo.Create( ProjectId.CreateNewId(), version, "proj", "assembly", "C#", analyzerReferences: ImmutableArray <AnalyzerReference> .Empty ); Assert.True(((ImmutableArray <AnalyzerReference>)info4.AnalyzerReferences).IsEmpty); }
public async Task When_custom_analyzers_are_executed_then_return_results() { using (var host = GetHost()) { var testFile = new TestFile("testFile_66.cs", "class _this_is_invalid_test_class_name { int n = true; }"); var testAnalyzerRef = new TestAnalyzerReference("TS1100"); var projectIds = AddProjectWitFile(host, testFile, testAnalyzerRef); var result = await host.RequestCodeCheckAsync("testFile_66.cs"); Assert.Contains(result.QuickFixes.OfType <DiagnosticLocation>(), f => f.Text.Contains(testAnalyzerRef.Id.ToString())); } }
public async Task When_custom_analyzers_are_executed_then_return_results() { using (var host = GetHost()) { var testFile = new TestFile("testFile.cs", "class _this_is_invalid_test_class_name { int n = true; }"); host.AddFilesToWorkspace(testFile); var testAnalyzerRef = new TestAnalyzerReference("TS1234", isEnabledByDefault: true); AddProjectWitFile(host, testFile, testAnalyzerRef); var result = await host.RequestCodeCheckAsync(); Assert.Contains(result.QuickFixes, f => f.Text.Contains(testAnalyzerRef.Id.ToString())); } }
public async Task When_diagnostic_is_disabled_by_default_updating_rule_will_enable_it() { using (var host = GetHost()) { var testFile = new TestFile("testFile_4.cs", "class _this_is_invalid_test_class_name { int n = true; }"); var testAnalyzerRef = new TestAnalyzerReference("TS1101", isEnabledByDefault: false); var projectId = AddProjectWitFile(host, testFile, testAnalyzerRef); var testRules = CreateRules(testAnalyzerRef.Id.ToString(), ReportDiagnostic.Error); host.Workspace.UpdateDiagnosticOptionsForProject(projectId, testRules.ToImmutableDictionary()); var result = await host.RequestCodeCheckAsync("testFile_4.cs"); Assert.Contains(result.QuickFixes, f => f.Text.Contains(testAnalyzerRef.Id.ToString())); } }
// This is important because hidden still allows code fixes to execute, not prevents it, for this reason suppressed analytics should not be returned at all. public async Task When_custom_rule_is_set_to_none_dont_return_results_at_all() { using (var host = GetHost()) { var testFile = new TestFile("testFile_3.cs", "class _this_is_invalid_test_class_name { int n = true; }"); var testAnalyzerRef = new TestAnalyzerReference("TS1101"); var projectId = AddProjectWitFile(host, testFile, testAnalyzerRef); var testRules = CreateRules(testAnalyzerRef.Id.ToString(), ReportDiagnostic.Suppress); host.Workspace.UpdateDiagnosticOptionsForProject(projectId, testRules.ToImmutableDictionary()); var result = await host.RequestCodeCheckAsync("testFile_3.cs"); Assert.DoesNotContain(result.QuickFixes, f => f.Text.Contains(testAnalyzerRef.Id.ToString())); } }
public async Task When_rules_udpate_diagnostic_severity_then_show_them_with_new_severity() { using (var host = GetHost()) { var testFile = new TestFile("testFile_2.cs", "class _this_is_invalid_test_class_name { int n = true; }"); var testAnalyzerRef = new TestAnalyzerReference("TS1100"); var projectId = AddProjectWitFile(host, testFile, testAnalyzerRef); var testRules = CreateRules(testAnalyzerRef.Id.ToString(), ReportDiagnostic.Hidden); host.Workspace.UpdateDiagnosticOptionsForProject(projectId, testRules.ToImmutableDictionary()); var result = await host.RequestCodeCheckAsync("testFile_2.cs"); var bar = result.QuickFixes.ToList(); Assert.Contains(result.QuickFixes.OfType <DiagnosticLocation>(), f => f.Text.Contains(testAnalyzerRef.Id.ToString()) && f.LogLevel == "Hidden"); } }
public void Create_Errors_DuplicateItems() { var pid = ProjectId.CreateNewId(); var documentInfo = DocumentInfo.Create(DocumentId.CreateNewId(pid), "doc"); Assert.Throws <ArgumentException>("documents[1]", () => ProjectInfo.Create(pid, VersionStamp.Default, "proj", "assembly", "C#", documents: new[] { documentInfo, documentInfo })); Assert.Throws <ArgumentNullException>(() => ProjectInfo.Create(pid, VersionStamp.Default, name: "Goo", assemblyName: "Bar", language: "C#", additionalDocuments: new DocumentInfo[] { null })); Assert.Throws <ArgumentException>("additionalDocuments[1]", () => ProjectInfo.Create(pid, VersionStamp.Default, "proj", "assembly", "C#", additionalDocuments: new[] { documentInfo, documentInfo })); Assert.Throws <ArgumentNullException>(() => ProjectInfo.Create(pid, VersionStamp.Default, name: "Goo", assemblyName: "Bar", language: "C#", projectReferences: new ProjectReference[] { null })); var projectReference = new ProjectReference(ProjectId.CreateNewId()); Assert.Throws <ArgumentException>("projectReferences[1]", () => ProjectInfo.Create(pid, VersionStamp.Default, "proj", "assembly", "C#", projectReferences: new[] { projectReference, projectReference })); Assert.Throws <ArgumentNullException>("analyzerReferences[0]", () => ProjectInfo.Create(pid, VersionStamp.Default, name: "Goo", assemblyName: "Bar", language: "C#", analyzerReferences: new AnalyzerReference[] { null })); var analyzerReference = new TestAnalyzerReference(); Assert.Throws <ArgumentException>("analyzerReferences[1]", () => ProjectInfo.Create(pid, VersionStamp.Default, "proj", "assembly", "C#", analyzerReferences: new[] { analyzerReference, analyzerReference })); Assert.Throws <ArgumentNullException>(() => ProjectInfo.Create(pid, VersionStamp.Default, name: "Goo", assemblyName: "Bar", language: "C#", metadataReferences: new MetadataReference[] { null })); var metadataReference = new TestMetadataReference(); Assert.Throws <ArgumentException>("metadataReferences[1]", () => ProjectInfo.Create(pid, VersionStamp.Default, "proj", "assembly", "C#", metadataReferences: new[] { metadataReference, metadataReference })); }
public async Task When_rules_udpate_diagnostic_severity_then_show_them_with_new_severity() { using (var host = GetHost()) { var testFile = new TestFile("testFile_2.cs", "class _this_is_invalid_test_class_name { int n = true; }"); var ruleService = host.GetExport <RulesetsForProjects>(); var testAnalyzerRef = new TestAnalyzerReference("TS1100"); var projectIds = AddProjectWitFile(host, testFile, testAnalyzerRef); var testRules = CreateRules(testAnalyzerRef.Id.ToString(), ReportDiagnostic.Hidden); ruleService.AddOrUpdateRuleset(projectIds.Single(), new RuleSet( "", new ReportDiagnostic(), testRules.ToImmutableDictionary(), new ImmutableArray <RuleSetInclude>())); var result = await host.RequestCodeCheckAsync("testFile_2.cs"); Assert.Contains(result.QuickFixes.OfType <DiagnosticLocation>(), f => f.Text.Contains(testAnalyzerRef.Id.ToString()) && f.LogLevel == "Hidden"); } }
public async Task When_diagnostic_is_disabled_by_default_updating_rule_will_enable_it() { using (var host = GetHost()) { var testFile = new TestFile("testFile_4.cs", "class _this_is_invalid_test_class_name { int n = true; }"); var ruleService = host.GetExport <RulesetsForProjects>(); var testAnalyzerRef = new TestAnalyzerReference("TS1101", isEnabledByDefault: false); var projectIds = AddProjectWitFile(host, testFile, testAnalyzerRef); var testRules = CreateRules(testAnalyzerRef.Id.ToString(), ReportDiagnostic.Error); ruleService.AddOrUpdateRuleset(projectIds.Single(), new RuleSet( "", new ReportDiagnostic(), testRules.ToImmutableDictionary(), new ImmutableArray <RuleSetInclude>())); var result = await host.RequestCodeCheckAsync("testFile_4.cs"); Assert.Contains(result.QuickFixes, f => f.Text.Contains(testAnalyzerRef.Id.ToString())); } }
private ProjectId AddProjectWitFile(OmniSharpTestHost host, TestFile testFile, TestAnalyzerReference testAnalyzerRef = null) { var analyzerReferences = testAnalyzerRef == null ? default : new AnalyzerReference[] { testAnalyzerRef }.ToImmutableArray(); return(TestHelpers.AddProjectToWorkspace( host.Workspace, "project.csproj", new[] { "netcoreapp2.1" }, new[] { testFile }, analyzerRefs: analyzerReferences) .Single()); }