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