public void TestMethodShouldContainAssertion_NUnit_FluentAssertionsLegacy(string testFwkVersion, string fluentVersion) =>
Verifier.VerifyCSharpAnalyzer(@"
using System;
using FluentAssertions;
using NUnit.Framework;
[TestFixture]
public class Foo
{
[Test]
public void Test1() // Noncompliant
{
var x = 42;
}
[Test]
public void ShouldThrowTest()
{
Action act = () => { throw new Exception(); };
act.ShouldThrow<Exception>();
}
[Test]
public void ShouldNotThrowTest()
{
Action act = () => { throw new Exception(); };
act.ShouldNotThrow<Exception>();
}
}",
new TestMethodShouldContainAssertion(),
additionalReferences:
NuGetMetadataReference.NUnit(testFwkVersion)
.Concat(NuGetMetadataReference.FluentAssertions(fluentVersion))
.Concat(MetadataReferenceFacade.GetSystemThreadingTasks()));
public void SqlKeywordsDelimitedBySpace_DotnetFramework(string sqlNamespace)
{
var references = MetadataReferenceFacade.GetSystemData()
.Concat(NuGetMetadataReference.Dapper())
.Concat(NuGetMetadataReference.EntityFramework())
.Concat(NuGetMetadataReference.MicrosoftDataSqliteCore())
.Concat(NuGetMetadataReference.MicrosoftSqlServerCompact())
.Concat(NuGetMetadataReference.NHibernate())
.Concat(NuGetMetadataReference.PetaPocoCompiled())
.Concat(NuGetMetadataReference.SystemDataOdbc())
.Concat(NuGetMetadataReference.SystemDataSqlClient())
.Concat(NuGetMetadataReference.SystemDataSQLiteCore());
Verifier.VerifyCSharpAnalyzer($@"
using {sqlNamespace};
namespace TestNamespace
{{
public class Test
{{
private string field = ""SELECT * FROM table"" +
""WHERE col ="" + // Noncompliant
""val"";
}}
}}
",
new SqlKeywordsDelimitedBySpace(),
additionalReferences: references.ToArray());
}
public void XmlExternalEntityShouldNotBeParsed_XPathDocument_CSharp9() =>
Verifier.VerifyAnalyzerFromCSharp9Console(@"TestCases\XmlExternalEntityShouldNotBeParsed_XPathDocument_CSharp9.cs",
new XmlExternalEntityShouldNotBeParsed(GetVersionProviderMock(NetFrameworkVersion.After452)),
MetadataReferenceFacade.GetSystemXml()
.Concat(MetadataReferenceFacade.GetSystemData())
.Concat(MetadataReferenceFacade.GetSystemXmlLinq())
.ToArray());
public void DoNotUseIif_CodeFix() =>
Verifier.VerifyCodeFix(
@"TestCases\DoNotUseIif.vb",
@"TestCases\DoNotUseIif.Fixed.vb",
new SonarAnalyzer.Rules.VisualBasic.DoNotUseIif(),
new SonarAnalyzer.Rules.VisualBasic.DoNotUseIifCodeFixProvider(),
additionalReferences: MetadataReferenceFacade.GetMicrosoftVisualBasic());
public void MethodShouldBeNamedAccordingToSynchronicity(string tasksVersion) =>
Verifier.VerifyAnalyzer(@"TestCases\MethodShouldBeNamedAccordingToSynchronicity.cs",
new MethodShouldBeNamedAccordingToSynchronicity(),
additionalReferences:
MetadataReferenceFacade.GetSystemThreadingTasksExtensions(tasksVersion)
.Union(MetadataReferenceFacade.GetSystemComponentModelPrimitives())
.Union(NuGetMetadataReference.MicrosoftAspNetSignalRCore()));
private ProjectBuilder AddProject(AnalyzerLanguage language, string projectName, bool createExtraEmptyFile)
{
var languageName = language == AnalyzerLanguage.CSharp
? LanguageNames.CSharp
: LanguageNames.VisualBasic;
var project = Solution.AddProject(projectName, projectName, languageName);
var projectBuilder = ProjectBuilder
.FromProject(project)
.AddReferences(MetadataReferenceFacade.GetProjectDefaultReferences());
if (language == AnalyzerLanguage.VisualBasic)
{
// Need a reference to the VB dll to be able to use the Module keyword
projectBuilder = projectBuilder.AddReferences(MetadataReferenceFacade.GetMicrosoftVisualBasic());
}
if (createExtraEmptyFile)
{
// adding an extra file to the project
// this won't trigger any issues, but it keeps a reference to the original ParseOption, so
// if an analyzer/codefix changes the language version, Roslyn throws an ArgumentException
projectBuilder = projectBuilder
.AddSnippet(string.Empty, fileName: "ExtraEmptyFile.g." + language.FileExtension);
}
return(projectBuilder);
}
public void ShouldImplementExportedInterfaces_Partial() =>
Verifier.VerifyAnalyzer(new[]
{
@"TestCases\ShouldImplementExportedInterfaces_Part1.cs",
@"TestCases\ShouldImplementExportedInterfaces_Part2.cs",
},
new ShouldImplementExportedInterfaces(),
additionalReferences: MetadataReferenceFacade.GetSystemComponentModelComposition());
public void XmlExternalEntityShouldNotBeParsed_XmlDocument(NetFrameworkVersion version, string testFilePath) =>
Verifier.VerifyAnalyzer(testFilePath,
new XmlExternalEntityShouldNotBeParsed(GetVersionProviderMock(version)),
additionalReferences: MetadataReferenceFacade.GetSystemXml()
.Concat(MetadataReferenceFacade.GetSystemData())
.Concat(MetadataReferenceFacade.GetSystemXmlLinq())
.Concat(NuGetMetadataReference.MicrosoftWebXdt())
.ToArray());
public void TestMethodShouldContainAssertion_Xunit_Legacy() =>
Verifier.VerifyAnalyzer(@"TestCases\TestMethodShouldContainAssertion.Xunit.Legacy.cs",
new TestMethodShouldContainAssertion(),
additionalReferences: NuGetMetadataReference.XunitFrameworkV1
.Concat(NuGetMetadataReference.FluentAssertions(Constants.NuGetLatestVersion))
.Concat(MetadataReferenceFacade.GetSystemXml())
.Concat(MetadataReferenceFacade.GetSystemXmlLinq())
.ToArray());
public void LdapConnectionsShouldBeSecure() =>
Verifier.VerifyAnalyzer(@"TestCases\LdapConnectionShouldBeSecure.cs",
new LdapConnectionShouldBeSecure(),
#if NETFRAMEWORK
additionalReferences: MetadataReferenceFacade.GetSystemDirectoryServices().Concat(NuGetMetadataReference.NETStandardV2_1_0),
#else
additionalReferences: MetadataReferenceFacade.GetSystemDirectoryServices(),
#endif
options: ParseOptionsHelper.FromCSharp8);
private static void VerifyRule(NetFrameworkVersion version, string testFilePath, OutputKind outputKind = OutputKind.DynamicallyLinkedLibrary, IEnumerable <ParseOptions> options = null) =>
Verifier.VerifyAnalyzer(testFilePath,
new XmlExternalEntityShouldNotBeParsed(GetVersionProviderMock(version)),
additionalReferences: MetadataReferenceFacade.GetSystemXml()
.Concat(MetadataReferenceFacade.GetSystemData())
.Concat(MetadataReferenceFacade.GetSystemXmlLinq())
.ToArray(),
outputKind: outputKind,
options: options);
public void XmlExternalEntityShouldNotBeParsed_NoCrashOnExternalParameterUse() =>
Verifier.VerifyAnalyzer(
new[]
{
@"TestCases\XmlExternalEntityShouldNotBeParsed_XmlReader_ExternalParameter.cs",
@"TestCases\XmlExternalEntityShouldNotBeParsed_XmlReader_ParameterProvider.cs"
},
new XmlExternalEntityShouldNotBeParsed(GetVersionProviderMock(NetFrameworkVersion.After452)),
additionalReferences: MetadataReferenceFacade.GetSystemXml());
public void TestMethodShouldContainAssertion_NUnit(string testFwkVersion, string fluentVersion, string nSubstituteVersion) =>
Verifier.VerifyAnalyzer(@"TestCases\TestMethodShouldContainAssertion.NUnit.cs",
new TestMethodShouldContainAssertion(),
additionalReferences: NuGetMetadataReference.NUnit(testFwkVersion)
.Concat(NuGetMetadataReference.FluentAssertions(fluentVersion))
.Concat(NuGetMetadataReference.NSubstitute(nSubstituteVersion))
.Concat(MetadataReferenceFacade.GetSystemXml())
.Concat(MetadataReferenceFacade.GetSystemXmlLinq())
.ToArray());
private static void VerifyRule(NetFrameworkVersion version, string testFilePath)
{
var rule = new XmlExternalEntityShouldNotBeParsed(GetVersionProviderMock(version));
Verifier.VerifyAnalyzer(testFilePath, rule,
additionalReferences: MetadataReferenceFacade.GetSystemXml()
.Concat(MetadataReferenceFacade.GetSystemData())
.Concat(MetadataReferenceFacade.GetSystemXmlLinq())
.ToArray());
}
public void XmlExternalEntityShouldNotBeParsed_XmlTextReader(NetFrameworkVersion version, string testFilePath)
{
// setup
var rule = new XmlExternalEntityShouldNotBeParsed(GetVersionProviderMock(version));
// act & verify
Verifier.VerifyAnalyzer(testFilePath, rule,
additionalReferences: MetadataReferenceFacade.GetSystemXml().ToArray(),
options: ParseOptionsHelper.FromCSharp8);
}
public void SonarAnalysis_ByDefault_ExecuteRule()
{
foreach (var testCase in TestCases)
{
// ToDo: We test that a rule is enabled only by checking the issues are reported
Verifier.VerifyAnalyzer(testCase.Path,
testCase.Analyzer,
ParseOptionsHelper.FromCSharp8,
additionalReferences: MetadataReferenceFacade.GetSystemComponentModelPrimitives());
}
}
public void XmlExternalEntityShouldNotBeParsed_XmlDocument(NetFrameworkVersion version, string testFilePath)
{
// setup
var rule = new XmlExternalEntityShouldNotBeParsed(GetVersionProviderMock(version));
// act & verify
Verifier.VerifyAnalyzer(testFilePath, rule,
additionalReferences: MetadataReferenceFacade.GetSystemXml()
.Concat(MetadataReferenceFacade.GetSystemData())
.Concat(MetadataReferenceFacade.GetSystemXmlLinq())
.Concat(NuGetMetadataReference.MicrosoftWebXdt())
.ToArray(),
options: ParseOptionsHelper.FromCSharp8);
}
public void ExactMatch_DoesNotMatchOverrides_VB()
{
var code = @"
Imports System.Xml
Namespace Test
Class Class1
Public Sub DoStuff(node As XmlNode, doc As XmlDocument)
node.WriteTo(Nothing)
doc.WriteTo(Nothing)
End Sub
End Class
End Namespace
";
var snippet = new SnippetCompiler(code, false, AnalyzerLanguage.VisualBasic,
MetadataReferenceFacade.GetSystemXml());
CheckExactMatch_DoesNotMatchOverrides(snippet);
}
public void SonarAnalysis_WhenReportDiagnosticActionNotNull_AllowToContolWhetherOrNotToReport()
{
try
{
SonarAnalysisContext.ReportDiagnostic = context =>
{
if (context.Diagnostic.Id != AnonymousDelegateEventUnsubscribe.DiagnosticId)
{
// Verifier expects all diagnostics to increase the counter in order to check that all rules call the
// extension method and not the direct `ReportDiagnostic`.
DiagnosticVerifier.SuppressionHandler.IncrementReportCount(context.Diagnostic.Id);
context.ReportDiagnostic(context.Diagnostic);
}
};
// Because the Verifier sets the SonarAnalysisContext.ShouldDiagnosticBeReported delegate we end up in a case
// where the Debug.Assert of the AnalysisContextExtensions.ReportDiagnostic() method will raise.
using (new AssertIgnoreScope())
{
foreach (var testCase in TestCases)
{
if (testCase.Analyzer is AnonymousDelegateEventUnsubscribe)
{
Verifier.VerifyNoIssueReported(testCase.Path,
testCase.Analyzer,
ParseOptionsHelper.FromCSharp8,
additionalReferences: MetadataReferenceFacade.GetSystemComponentModelPrimitives());
}
else
{
Verifier.VerifyAnalyzer(testCase.Path,
testCase.Analyzer,
ParseOptionsHelper.FromCSharp8,
additionalReferences: MetadataReferenceFacade.GetSystemComponentModelPrimitives());
}
}
}
}
finally
{
SonarAnalysisContext.ReportDiagnostic = null;
}
}
public void SonarAnalysis_WhenShouldAnalysisBeDisabledReturnsTrue_NoIssueReported()
{
SonarAnalysisContext.ShouldExecuteRegisteredAction = (diags, tree) => false;
try
{
foreach (var testCase in TestCases)
{
// ToDo: We should find a way to ack the fact the action was not run
Verifier.VerifyNoIssueReported(testCase.Path,
testCase.Analyzer,
ParseOptionsHelper.FromCSharp8,
additionalReferences: MetadataReferenceFacade.GetSystemComponentModelPrimitives());
}
}
finally
{
SonarAnalysisContext.ShouldExecuteRegisteredAction = null;
}
}
public void TestMethodShouldContainAssertion_NUnit_V2Specific(string testFwkVersion) =>
Verifier.VerifyCSharpAnalyzer(@"
using System;
using NUnit.Framework;
[TestFixture]
public class Foo
{
[TestCase]
[ExpectedException(typeof(Exception))]
public void TestCase4()
{
var x = System.IO.File.Open("""", System.IO.FileMode.Open);
}
[Theory]
[ExpectedException(typeof(Exception))]
public void Theory4()
{
var x = System.IO.File.Open("""", System.IO.FileMode.Open);
}
[TestCaseSource(""Foo"")]
[ExpectedException(typeof(Exception))]
public void TestCaseSource4()
{
var x = System.IO.File.Open("""", System.IO.FileMode.Open);
}
[Test]
[ExpectedException(typeof(Exception))]
public void Test4()
{
var x = System.IO.File.Open("""", System.IO.FileMode.Open);
}
}",
new TestMethodShouldContainAssertion(),
additionalReferences: NuGetMetadataReference.NUnit(testFwkVersion)
.Concat(MetadataReferenceFacade.GetSystemXml())
.Concat(MetadataReferenceFacade.GetSystemXmlLinq())
.ToArray());
public void IsMatch_AndCheckingOverrides_DoesMatchOverrides_CS()
{
var code = @"
namespace Test
{
using System.Xml;
class Class1
{
public void DoStuff(XmlNode node, XmlDocument doc)
{
node.WriteTo(null);
doc.WriteTo(null);
}
}
}
";
var snippet = new SnippetCompiler(code, MetadataReferenceFacade.GetSystemXml());
CheckIsMatch_AndCheckingOverrides_DoesMatchOverrides(snippet);
}
public void SqlKeywordsDelimitedBySpace_DotnetCore(string sqlNamespace)
{
var references = MetadataReferenceFacade.GetSystemData()
.Concat(NuGetMetadataReference.MicrosoftEntityFrameworkCore("2.2.0"))
.Concat(NuGetMetadataReference.ServiceStackOrmLite())
.Concat(NuGetMetadataReference.SystemDataSqlClient())
.Concat(NuGetMetadataReference.SystemDataOracleClient());
Verifier.VerifyCSharpAnalyzer($@"
using {sqlNamespace};
namespace TestNamespace
{{
public class Test
{{
private string field = ""SELECT * FROM table"" +
""WHERE col ="" + // Noncompliant
""val"";
}}
}}
",
new SqlKeywordsDelimitedBySpace(),
additionalReferences: references.ToArray());
}
private ProjectBuilder AddProject(AnalyzerLanguage language, string projectName, bool createExtraEmptyFile, OutputKind outputKind = OutputKind.DynamicallyLinkedLibrary)
{
var languageName = language == AnalyzerLanguage.CSharp
? LanguageNames.CSharp
: LanguageNames.VisualBasic;
var project = Solution.AddProject(projectName, projectName, languageName);
var compilationOptions = project.CompilationOptions.WithOutputKind(outputKind);
if (languageName == LanguageNames.CSharp)
{
compilationOptions = ((CSharpCompilationOptions)compilationOptions).WithAllowUnsafe(true);
}
project = project.WithCompilationOptions(compilationOptions);
var projectBuilder = ProjectBuilder
.FromProject(project)
.AddReferences(MetadataReferenceFacade.GetProjectDefaultReferences());
if (language == AnalyzerLanguage.VisualBasic)
{
// Need a reference to the VB dll to be able to use the Module keyword
projectBuilder = projectBuilder.AddReferences(MetadataReferenceFacade.GetMicrosoftVisualBasic());
}
if (createExtraEmptyFile)
{
// adding an extra file to the project
// this won't trigger any issues, but it keeps a reference to the original ParseOption, so
// if an analyzer/codefix changes the language version, Roslyn throws an ArgumentException
projectBuilder = projectBuilder
.AddSnippet(string.Empty, fileName: "ExtraEmptyFile.g." + language.FileExtension);
}
return(projectBuilder);
}
public void GetHashCodeEqualsOverride_CSharp9() =>
Verifier.VerifyAnalyzerFromCSharp9Library(@"TestCases\GetHashCodeEqualsOverride.CSharp9.cs",
new GetHashCodeEqualsOverride(),
additionalReferences: MetadataReferenceFacade.GetSystemComponentModelPrimitives());
public void WcfNonVoidOneWay_VB() =>
Verifier.VerifyAnalyzer(@"TestCases\WcfNonVoidOneWay.vb",
new SonarAnalyzer.Rules.VisualBasic.WcfNonVoidOneWay(),
additionalReferences: MetadataReferenceFacade.GetSystemServiceModel());
public void WcfNonVoidOneWay_CS() =>
Verifier.VerifyAnalyzer(@"TestCases\WcfNonVoidOneWay.cs",
new WcfNonVoidOneWay(),
additionalReferences: MetadataReferenceFacade.GetSystemServiceModel());
public void ReturnEmptyCollectionInsteadOfNull() =>
Verifier.VerifyAnalyzer(@"TestCases\ReturnEmptyCollectionInsteadOfNull.cs",
new ReturnEmptyCollectionInsteadOfNull(),
additionalReferences: MetadataReferenceFacade.GetSystemXml());
public void LiteralsShouldNotBePassedAsLocalizedParameters_CSharp9() =>
Verifier.VerifyAnalyzerFromCSharp9Console(@"TestCases\LiteralsShouldNotBePassedAsLocalizedParameters.CSharp9.cs",
new LiteralsShouldNotBePassedAsLocalizedParameters(),
additionalReferences: MetadataReferenceFacade.GetSystemComponentModelPrimitives());
public void CollectionsShouldImplementGenericInterface() =>
Verifier.VerifyAnalyzer(@"TestCases\CollectionsShouldImplementGenericInterface.cs",
new CollectionsShouldImplementGenericInterface(),
additionalReferences: MetadataReferenceFacade.GetSystemCollections(),
checkMode: CompilationErrorBehavior.Ignore); // It would be too tedious to implement all those interfaces
