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