C# (CSharp) NuGetMetadataReferenceの例

コード例 #1

ファイル: AspNetMvcHelper_IsControllerMethod.cs プロジェクト: yunfan501/sonardotnet714

        public void Methods_In_Classes_With_NonControllerAttribute_Are_Not_EntryPoints(string aspNetMvcVersion)
        {
            const string code        = @"
[Microsoft.AspNetCore.Mvc.NonControllerAttribute]
public class Foo : Microsoft.AspNetCore.Mvc.ControllerBase
{
    public void PublicFoo() { }
}
";
            var          compilation = TestHelper.Compile(code,
                                                          additionalReferences:
                                                          FrameworkMetadataReference.Netstandard
                                                          .Union(NuGetMetadataReference.MicrosoftAspNetCoreMvcCore(aspNetMvcVersion))
                                                          .ToArray());

            var publicFoo = compilation.GetMethodSymbol("PublicFoo");

            AspNetMvcHelper.IsControllerMethod(publicFoo).Should().Be(false);
        }

コード例 #2

ファイル: TestMethodShouldContainAssertionTest.cs プロジェクト: slipalison/sonar-dotnet

        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(FrameworkMetadataReference.SystemXml)
                                          .Concat(FrameworkMetadataReference.SystemXmlLinq)
                                          .ToArray());
        }

コード例 #3

        public void Methods_In_Classes_With_ControllerAttribute_Are_EntryPoints(string aspNetMvcVersion)
        {
            const string code        = @"
// The Attribute suffix is required because we don't have a reference
// to ASP.NET Core and we cannot do type checking in the test project.
// We will need to convert this test project to .NET Core to do that.
[Microsoft.AspNetCore.Mvc.ControllerAttribute]
public class Foo
{
    public void PublicFoo() { }
}
";
            var          compilation = TestHelper.Compile(code,
                                                          additionalReferences:  NuGetMetadataReference.MicrosoftAspNetMvc(aspNetMvcVersion));

            var publicFoo = compilation.GetMethodSymbol("PublicFoo");

            AspNetMvcHelper.IsControllerMethod(publicFoo).Should().Be(true);
        }

コード例 #4

        public void SqlKeywordsDelimitedBySpace_DotnetCore(string sqlNamespace)
        {
            var references = MetadataReferenceFacade.SystemData
                             .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 CS.SqlKeywordsDelimitedBySpace(), references.ToArray());
        }

コード例 #5

ファイル: TestMethodShouldContainAssertionTest.cs プロジェクト: slipalison/sonar-dotnet

        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(FrameworkMetadataReference.SystemThreadingTasks)
                                          .ToArray());
        }

コード例 #6

        public void IsTest_ReturnsTrueForTestFrameworks()
        {
            IsTest(NuGetMetadataReference.JetBrainsDotMemoryUnit(Constants.NuGetLatestVersion)).Should().BeTrue();
            IsTest(NuGetMetadataReference.MSTestTestFrameworkV1).Should().BeTrue();
            IsTest(NuGetMetadataReference.MSTestTestFramework(Constants.NuGetLatestVersion)).Should().BeTrue();
            IsTest(NuGetMetadataReference.MicrosoftVisualStudioQualityToolsUnitTestFramework).Should().BeTrue();
            IsTest(NuGetMetadataReference.MachineSpecifications(Constants.NuGetLatestVersion)).Should().BeTrue();
            IsTest(NuGetMetadataReference.NUnit(Constants.NuGetLatestVersion)).Should().BeTrue();
            IsTest(NuGetMetadataReference.NUnitLite(Constants.NuGetLatestVersion)).Should().BeTrue();
            IsTest(NuGetMetadataReference.SpecFlow(Constants.NuGetLatestVersion)).Should().BeTrue();
            IsTest(NuGetMetadataReference.XunitFrameworkV1).Should().BeTrue();
            IsTest(NuGetMetadataReference.XunitFramework(Constants.NuGetLatestVersion)).Should().BeTrue();

            // Assertion
            IsTest(NuGetMetadataReference.FluentAssertions(Constants.NuGetLatestVersion)).Should().BeTrue();
            IsTest(NuGetMetadataReference.Shouldly(Constants.NuGetLatestVersion)).Should().BeTrue();

            // Mock
            IsTest(NuGetMetadataReference.FakeItEasy(Constants.NuGetLatestVersion)).Should().BeTrue();
            IsTest(NuGetMetadataReference.JustMock(Constants.NuGetLatestVersion)).Should().BeTrue();
            IsTest(NuGetMetadataReference.Moq(Constants.NuGetLatestVersion)).Should().BeTrue();
            IsTest(NuGetMetadataReference.NSubstitute(Constants.NuGetLatestVersion)).Should().BeTrue();
            IsTest(NuGetMetadataReference.RhinoMocks(Constants.NuGetLatestVersion)).Should().BeTrue();
        }

コード例 #7

 public void ExpectedExceptionAttributeShouldNotBeUsed_NUnit(string testFwkVersion)
 {
     Verifier.VerifyAnalyzer(@"TestCases\ExpectedExceptionAttributeShouldNotBeUsed.NUnit.cs",
                             new ExpectedExceptionAttributeShouldNotBeUsed(),
                             additionalReferences: NuGetMetadataReference.NUnit(testFwkVersion));
 }

コード例 #8

 public void TestMethodShouldContainAssertion_MSTest(string testFwkVersion) =>
 Verifier.VerifyAnalyzer(new[] { @"TestCases\TestMethodShouldContainAssertion.MsTest.cs", @"TestCases\TestMethodShouldContainAssertion.MsTest.AnotherFile.cs" },
                         new CS.TestMethodShouldContainAssertion(),
                         AdditionalTestReferences(NuGetMetadataReference.MSTestTestFramework(testFwkVersion)));

コード例 #9

ファイル: RequestsWithExcessiveLengthTest.cs プロジェクト: zhamppx97/sonar-dotnet

 internal static IEnumerable <MetadataReference> GetAdditionalReferences() =>
 NetStandardMetadataReference.Netstandard
 .Concat(NuGetMetadataReference.MicrosoftAspNetCoreMvcCore(Constants.NuGetLatestVersion))
 .Concat(NuGetMetadataReference.MicrosoftAspNetCoreMvcViewFeatures(Constants.NuGetLatestVersion));

コード例 #10

ファイル: DisablingRequestValidationTest.cs プロジェクト: zhamppx97/sonar-dotnet

 public void DisablingRequestValidation_CS() =>
 Verifier.VerifyAnalyzer(@"TestCases\Hotspots\DisablingRequestValidation.cs",
                         new CS.DisablingRequestValidation(AnalyzerConfiguration.AlwaysEnabled),
                         additionalReferences: NuGetMetadataReference.MicrosoftAspNetMvc(AspNetMvcVersion));

コード例 #11

ファイル: CookieShouldBeHttpOnlyTest.cs プロジェクト: zhamppx97/sonar-dotnet

 private static IEnumerable <MetadataReference> GetAdditionalReferences_NetCore() =>
 NuGetMetadataReference.MicrosoftAspNetCoreHttpFeatures(Constants.NuGetLatestVersion);

コード例 #12

ファイル: TestMethodShouldNotBeIgnoredTest.cs プロジェクト: slipalison/sonar-dotnet

 public void TestMethodShouldNotBeIgnored_MsTest(string testFwkVersion)
 {
     Verifier.VerifyAnalyzer(@"TestCases\TestMethodShouldNotBeIgnored.MsTest.cs",
                             new TestMethodShouldNotBeIgnored(),
                             additionalReferences: NuGetMetadataReference.MSTestTestFramework(testFwkVersion));
 }

コード例 #13

ファイル: CookieShouldBeSecureTest.cs プロジェクト: touzas/sonar-dotnet

 public void CookiesShouldBeSecure_Nancy() =>
 Verifier.VerifyAnalyzer(@"TestCases\CookiesShouldBeSecure_Nancy.cs",
                         new CookieShouldBeSecure(AnalyzerConfiguration.AlwaysEnabled),
                         additionalReferences: NuGetMetadataReference.Nancy());

コード例 #14

ファイル: CookieShouldBeSecureTest.cs プロジェクト: arunsidhu90/sonar-dotnet

 private static IEnumerable <MetadataReference> GetAdditionalReferences_NetCore() =>
 FrameworkMetadataReference.Netstandard
 .Concat(NuGetMetadataReference.MicrosoftAspNetCoreHttpFeatures(Constants.NuGetLatestVersion));

コード例 #15

ファイル: InsecureEncryptionAlgorithmTest.cs プロジェクト: ewin66/sonar-dotnet

 private static IEnumerable <MetadataReference> GetAdditionalReferences() =>
 MetadataReferenceFacade.GetSystemSecurityCryptography()
 .Concat(NuGetMetadataReference.BouncyCastle());

コード例 #16

 public void JwtSigned_CS()
 {
     Verifier.VerifyAnalyzer(@"TestCases\JwtSigned.cs",
                             new csharp.JwtSigned(),
                             additionalReferences: NuGetMetadataReference.JWT());
 }

コード例 #17

 public void JwtSigned_VB()
 {
     Verifier.VerifyAnalyzer(@"TestCases\JwtSigned.vb",
                             new vbnet.JwtSigned(),
                             additionalReferences: NuGetMetadataReference.JWT());
 }

コード例 #18

ファイル: TestClassShouldHaveTestMethodTest.cs プロジェクト: arunsidhu90/sonar-dotnet

 public void TestClassShouldHaveTestMethod_NUnit(string testFwkVersion)
 {
     Verifier.VerifyAnalyzer(@"TestCases\TestClassShouldHaveTestMethod.NUnit.cs",
                             new TestClassShouldHaveTestMethod(),
                             additionalReferences: NuGetMetadataReference.NUnit(testFwkVersion));
 }

コード例 #19

ファイル: TestMethodShouldHaveCorrectSignature.cs プロジェクト: arunsidhu90/sonar-dotnet

 public void TestMethodShouldHaveCorrectSignature_Xunit(string testFwkVersion)
 {
     Verifier.VerifyAnalyzer(@"TestCases\TestMethodShouldHaveCorrectSignature.Xunit.cs",
                             new TestMethodShouldHaveCorrectSignature(),
                             additionalReferences: NuGetMetadataReference.XunitFramework(testFwkVersion));
 }

コード例 #20

 public void JwtSigned_CS_FromCSharp9() =>
 Verifier.VerifyAnalyzerFromCSharp9Console(@"TestCases\JwtSigned.CSharp9.cs", new csharp.JwtSigned(), NuGetMetadataReference.JWT("6.1.0"));

コード例 #21

 public void AssertionArgsShouldBePassedInCorrectOrder_NUnit(string testFwkVersion)
 {
     Verifier.VerifyAnalyzer(@"TestCases\AssertionArgsShouldBePassedInCorrectOrder.NUnit.cs",
                             new AssertionArgsShouldBePassedInCorrectOrder(),
                             additionalReferences: NuGetMetadataReference.NUnit(testFwkVersion));
 }

コード例 #22

 public void JwtSigned_JWTDecoderExtensions_VB() =>
 Verifier.VerifyAnalyzer(@"TestCases\JwtSigned.Extensions.vb", new vbnet.JwtSigned(), additionalReferences: NuGetMetadataReference.JWT("7.3.1"));

コード例 #23

ファイル: DisablingRequestValidationTest.cs プロジェクト: zhamppx97/sonar-dotnet

 public void DisablingRequestValidation_CS_Disabled() =>
 Verifier.VerifyNoIssueReported(@"TestCases\Hotspots\DisablingRequestValidation.cs",
                                new CS.DisablingRequestValidation(AnalyzerConfiguration.Hotspot),
                                additionalReferences: NuGetMetadataReference.MicrosoftAspNetMvc(AspNetMvcVersion));

コード例 #24

ファイル: ConsumeValueTaskCorrectlyTest.cs プロジェクト: pizycki/sonar-dotnet

 private static IEnumerable <MetadataReference> GetReferences() =>
 Enumerable.Empty <MetadataReference>()
 .Concat(FrameworkMetadataReference.SystemThreadingTasks)
 .Concat(NuGetMetadataReference.SystemThreadingTasksExtensions("4.0.0"));

コード例 #25

 public void TestMethodShouldContainAssertion_CustomAssertionMethod() =>
 Verifier.VerifyAnalyzer(@"TestCases\TestMethodShouldContainAssertion.Custom.cs",
                         new CS.TestMethodShouldContainAssertion(),
                         NuGetMetadataReference.MSTestTestFramework(Constants.NuGetLatestVersion));

コード例 #26

ファイル: DoNotUseLiteralBoolInAssertionsTest.cs プロジェクト: slipalison/sonar-dotnet

 public void DoNotUseLiteralBoolInAssertions_Xunit(string testFwkVersion)
 {
     Verifier.VerifyAnalyzer(@"TestCases\DoNotUseLiteralBoolInAssertions.Xunit.cs",
                             new DoNotUseLiteralBoolInAssertions(),
                             additionalReferences: NuGetMetadataReference.XunitFramework(testFwkVersion));
 }

コード例 #27

 public void TestMethodShouldContainAssertion_NUnit(string testFwkVersion, string fluentVersion, string nSubstituteVersion) =>
 Verifier.VerifyAnalyzer(@"TestCases\TestMethodShouldContainAssertion.NUnit.cs",
                         new CS.TestMethodShouldContainAssertion(),
                         AdditionalTestReferences(NuGetMetadataReference.NUnit(testFwkVersion), fluentVersion, nSubstituteVersion));

コード例 #28

ファイル: ExecutingSqlQueriesTest.cs プロジェクト: rehen/sonar-dotnet

 internal static IEnumerable <MetadataReference> GetReferencesNetCore(string entityFrameworkVersion) =>
 Enumerable.Empty <MetadataReference>()
 .Concat(NuGetMetadataReference.MicrosoftEntityFrameworkCore(entityFrameworkVersion))
 .Concat(NuGetMetadataReference.MicrosoftEntityFrameworkCoreRelational(entityFrameworkVersion));

コード例 #29

ファイル: MutableFieldsShouldNotBePublicReadonlyTest.cs プロジェクト: ewin66/sonar-dotnet

 public void PublicMutableFieldsShouldNotBeReadonly()
 {
     Verifier.VerifyAnalyzer(@"TestCases\MutableFieldsShouldNotBePublicReadonly.cs",
                             new MutableFieldsShouldNotBePublicReadonly(),
                             additionalReferences: NuGetMetadataReference.SystemCollectionsImmutable("1.3.0"));
 }

コード例 #30

ファイル: CookieShouldBeHttpOnlyTest.cs プロジェクト: asears/sonar-dotnet

 public void CookiesShouldBeHttpOnly_Nancy() =>
 Verifier.VerifyAnalyzer(@"TestCases\CookieShouldBeHttpOnly_Nancy.cs",
                         new CS.CookieShouldBeHttpOnly(AnalyzerConfiguration.AlwaysEnabled),
                         NuGetMetadataReference.Nancy());