[GH-144] - handling protected internal constructors when analyzing NS…

…2001 diagnostic (#145)
nsubstitute · Sep 7, 2020 · 8d9dc15 · 8d9dc15
1 parent d31a559
commit 8d9dc15
Show file tree

Hide file tree

Showing 14 changed files with 980 additions and 15 deletions.
diff --git a/...NSubstitute.Analyzers.Shared/DiagnosticAnalyzers/AbstractSubstituteConstructorAnalysis.cs b/...NSubstitute.Analyzers.Shared/DiagnosticAnalyzers/AbstractSubstituteConstructorAnalysis.cs
@@ -115,12 +115,27 @@ private IMethodSymbol[] GetAccessibleConstructors(ITypeSymbol genericArgument)
         {
             var internalsVisibleToProxy = genericArgument.InternalsVisibleToProxyGenerator();
 
+            bool IsAccessible(IMethodSymbol symbol)
+            {
+                return symbol.DeclaredAccessibility == Accessibility.Protected ||
+                       symbol.DeclaredAccessibility == Accessibility.Public;
+            }
+
+            bool IsVisibleToProxy(IMethodSymbol symbol)
+            {
+                if (internalsVisibleToProxy == false)
+                {
+                    return false;
+                }
+
+                return symbol.DeclaredAccessibility == Accessibility.Internal ||
+                       symbol.DeclaredAccessibility == Accessibility.ProtectedOrInternal;
+            }
+
             return genericArgument.GetMembers().OfType<IMethodSymbol>().Where(symbol =>
                 symbol.MethodKind == MethodKind.Constructor &&
                 symbol.IsStatic == false &&
-                (symbol.DeclaredAccessibility == Accessibility.Protected ||
-                 symbol.DeclaredAccessibility == Accessibility.Public ||
-                 (internalsVisibleToProxy && symbol.DeclaredAccessibility == Accessibility.Internal))).ToArray();
+                (IsAccessible(symbol) || IsVisibleToProxy(symbol))).ToArray();
         }
 
         private TypeInfo GetTypeInfo(SubstituteContext<TInvocationExpression> substituteContext, SyntaxNode syntax)

diff --git a/...s.Tests.CSharp/DiagnosticAnalyzerTests/SubstituteAnalyzerTests/ForAsGenericMethodTests.cs b/...s.Tests.CSharp/DiagnosticAnalyzerTests/SubstituteAnalyzerTests/ForAsGenericMethodTests.cs
@@ -250,6 +250,106 @@ public void Test()
             await VerifyDiagnostic(source, SubstituteForWithoutAccessibleConstructorDescriptor, "Could not find accessible constructor. Make sure that type MyNamespace.Foo exposes public or protected constructors.");
         }
 
+        public override async Task ReturnsDiagnostic_WhenUsedForClassWithInternalConstructor_AndInternalsVisibleToNotApplied()
+        {
+            var source = @"using NSubstitute;
+
+namespace MyNamespace
+{
+    public class Foo
+    {
+        internal Foo()
+        {
+        }
+    }
+
+    public class FooTests
+    {
+        public void Test()
+        {
+            var substitute = [|NSubstitute.Substitute.For<Foo>()|];
+        }
+    }
+}";
+            await VerifyDiagnostic(source, SubstituteForWithoutAccessibleConstructorDescriptor, "Could not find accessible constructor. Make sure that type MyNamespace.Foo exposes public or protected constructors.");
+        }
+
+        public override async Task ReturnsDiagnostic_WhenUsedForClassWithProtectedInternalConstructor_AndInternalsVisibleToNotApplied()
+        {
+            var source = @"using NSubstitute;
+
+namespace MyNamespace
+{
+    public class Foo
+    {
+        protected internal Foo()
+        {
+        }
+    }
+
+    public class FooTests
+    {
+        public void Test()
+        {
+            var substitute = [|NSubstitute.Substitute.For<Foo>()|];
+        }
+    }
+}";
+            await VerifyDiagnostic(source, SubstituteForWithoutAccessibleConstructorDescriptor, "Could not find accessible constructor. Make sure that type MyNamespace.Foo exposes public or protected constructors.");
+        }
+
+        public override async Task ReturnsNoDiagnostic_WhenUsedForClassWithInternalConstructor_AndInternalsVisibleToApplied()
+        {
+            var source = @"using NSubstitute;
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo(""DynamicProxyGenAssembly2"")]
+namespace MyNamespace
+{
+    public class Foo
+    {
+        internal Foo()
+        {
+        }
+    }
+
+    public class FooTests
+    {
+        public void Test()
+        {
+            var substitute = NSubstitute.Substitute.For<Foo>();
+        }
+    }
+}";
+            await VerifyNoDiagnostic(source);
+        }
+
+        public override async Task ReturnsNoDiagnostic_WhenUsedForClassWithProtectedInternalConstructor_AndInternalsVisibleToApplied()
+        {
+            var source = @"using NSubstitute;
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo(""DynamicProxyGenAssembly2"")]
+namespace MyNamespace
+{
+    public class Foo
+    {
+        protected internal Foo()
+        {
+        }
+    }
+
+    public class FooTests
+    {
+        public void Test()
+        {
+            var substitute = NSubstitute.Substitute.For<Foo>();
+        }
+    }
+}";
+            await VerifyNoDiagnostic(source);
+        }
+
         [Fact]
         public override async Task ReturnsDiagnostic_WhenPassedParametersCount_GreaterThanCtorParametersCount()
         {

diff --git a/...ests.CSharp/DiagnosticAnalyzerTests/SubstituteAnalyzerTests/ForAsNonGenericMethodTests.cs b/...ests.CSharp/DiagnosticAnalyzerTests/SubstituteAnalyzerTests/ForAsNonGenericMethodTests.cs
@@ -304,6 +304,106 @@ public void Test()
             await VerifyDiagnostic(source, SubstituteForWithoutAccessibleConstructorDescriptor, "Could not find accessible constructor. Make sure that type MyNamespace.Foo exposes public or protected constructors.");
         }
 
+        public override async Task ReturnsDiagnostic_WhenUsedForClassWithInternalConstructor_AndInternalsVisibleToNotApplied()
+        {
+            var source = @"using NSubstitute;
+
+namespace MyNamespace
+{
+    public class Foo
+    {
+        internal Foo()
+        {
+        }
+    }
+
+    public class FooTests
+    {
+        public void Test()
+        {
+            var substitute = [|NSubstitute.Substitute.For(new [] { typeof(Foo) }, null)|];
+        }
+    }
+}";
+            await VerifyDiagnostic(source, SubstituteForWithoutAccessibleConstructorDescriptor, "Could not find accessible constructor. Make sure that type MyNamespace.Foo exposes public or protected constructors.");
+        }
+
+        public override async Task ReturnsDiagnostic_WhenUsedForClassWithProtectedInternalConstructor_AndInternalsVisibleToNotApplied()
+        {
+            var source = @"using NSubstitute;
+
+namespace MyNamespace
+{
+    public class Foo
+    {
+        protected internal Foo()
+        {
+        }
+    }
+
+    public class FooTests
+    {
+        public void Test()
+        {
+            var substitute = [|NSubstitute.Substitute.For(new [] { typeof(Foo) }, null)|];
+        }
+    }
+}";
+            await VerifyDiagnostic(source, SubstituteForWithoutAccessibleConstructorDescriptor, "Could not find accessible constructor. Make sure that type MyNamespace.Foo exposes public or protected constructors.");
+        }
+
+        public override async Task ReturnsNoDiagnostic_WhenUsedForClassWithInternalConstructor_AndInternalsVisibleToApplied()
+        {
+            var source = @"using NSubstitute;
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo(""DynamicProxyGenAssembly2"")]
+namespace MyNamespace
+{
+    public class Foo
+    {
+        internal Foo()
+        {
+        }
+    }
+
+    public class FooTests
+    {
+        public void Test()
+        {
+            var substitute = NSubstitute.Substitute.For(new [] { typeof(Foo) }, null);
+        }
+    }
+}";
+            await VerifyNoDiagnostic(source);
+        }
+
+        public override async Task ReturnsNoDiagnostic_WhenUsedForClassWithProtectedInternalConstructor_AndInternalsVisibleToApplied()
+        {
+            var source = @"using NSubstitute;
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo(""DynamicProxyGenAssembly2"")]
+namespace MyNamespace
+{
+    public class Foo
+    {
+        protected internal Foo()
+        {
+        }
+    }
+
+    public class FooTests
+    {
+        public void Test()
+        {
+            var substitute = NSubstitute.Substitute.For(new [] { typeof(Foo) }, null);
+        }
+    }
+}";
+            await VerifyNoDiagnostic(source);
+        }
+
         [Fact]
         public override async Task ReturnsDiagnostic_WhenPassedParametersCount_GreaterThanCtorParametersCount()
         {

diff --git a/...ers.Tests.CSharp/DiagnosticAnalyzerTests/SubstituteAnalyzerTests/ForPartsOfMethodTests.cs b/...ers.Tests.CSharp/DiagnosticAnalyzerTests/SubstituteAnalyzerTests/ForPartsOfMethodTests.cs
@@ -80,6 +80,108 @@ public void Test()
             await VerifyDiagnostic(source, SubstituteForWithoutAccessibleConstructorDescriptor, "Could not find accessible constructor. Make sure that type MyNamespace.Foo exposes public or protected constructors.");
         }
 
+        public override async Task ReturnsDiagnostic_WhenUsedForClassWithInternalConstructor_AndInternalsVisibleToNotApplied()
+        {
+            var source = @"using NSubstitute;
+
+namespace MyNamespace
+{
+    public class Foo
+    {
+        internal Foo()
+        {
+        }
+    }
+
+    public class FooTests
+    {
+        public void Test()
+        {
+            var substitute = [|NSubstitute.Substitute.ForPartsOf<Foo>()|];
+        }
+    }
+}";
+            await VerifyDiagnostic(source, SubstituteForWithoutAccessibleConstructorDescriptor, "Could not find accessible constructor. Make sure that type MyNamespace.Foo exposes public or protected constructors.");
+        }
+
+        public override async Task ReturnsDiagnostic_WhenUsedForClassWithProtectedInternalConstructor_AndInternalsVisibleToNotApplied()
+        {
+            var source = @"using NSubstitute;
+
+namespace MyNamespace
+{
+    public class Foo
+    {
+        protected internal Foo()
+        {
+        }
+    }
+
+    public class FooTests
+    {
+        public void Test()
+        {
+            var substitute = [|NSubstitute.Substitute.ForPartsOf<Foo>()|];
+        }
+    }
+}";
+            await VerifyDiagnostic(source, SubstituteForWithoutAccessibleConstructorDescriptor, "Could not find accessible constructor. Make sure that type MyNamespace.Foo exposes public or protected constructors.");
+        }
+
+        public override async Task ReturnsNoDiagnostic_WhenUsedForClassWithInternalConstructor_AndInternalsVisibleToApplied()
+        {
+            var source = @"using NSubstitute;
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo(""DynamicProxyGenAssembly2"")]
+
+namespace MyNamespace
+{
+    public class Foo
+    {
+        internal Foo()
+        {
+        }
+    }
+
+    public class FooTests
+    {
+        public void Test()
+        {
+            var substitute = NSubstitute.Substitute.ForPartsOf<Foo>();
+        }
+    }
+}";
+            await VerifyNoDiagnostic(source);
+        }
+
+        public override async Task ReturnsNoDiagnostic_WhenUsedForClassWithProtectedInternalConstructor_AndInternalsVisibleToApplied()
+        {
+            var source = @"using NSubstitute;
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo(""DynamicProxyGenAssembly2"")]
+
+namespace MyNamespace
+{
+    public class Foo
+    {
+        protected internal Foo()
+        {
+        }
+    }
+
+    public class FooTests
+    {
+        public void Test()
+        {
+            var substitute = NSubstitute.Substitute.ForPartsOf<Foo>();
+        }
+    }
+}";
+            await VerifyNoDiagnostic(source);
+        }
+
         [Fact]
         public override async Task ReturnsDiagnostic_WhenPassedParametersCount_GreaterThanCtorParametersCount()
         {

diff --git a/...ts.CSharp/DiagnosticAnalyzerTests/SubstituteAnalyzerTests/SubstituteDiagnosticVerifier.cs b/...ts.CSharp/DiagnosticAnalyzerTests/SubstituteAnalyzerTests/SubstituteDiagnosticVerifier.cs
@@ -33,6 +33,18 @@ public abstract class SubstituteDiagnosticVerifier : CSharpDiagnosticVerifier, I
         [Fact]
         public abstract Task ReturnsDiagnostic_WhenUsedForClassWithoutPublicOrProtectedConstructor();
 
+        [Fact]
+        public abstract Task ReturnsDiagnostic_WhenUsedForClassWithInternalConstructor_AndInternalsVisibleToNotApplied();
+
+        [Fact]
+        public abstract Task ReturnsDiagnostic_WhenUsedForClassWithProtectedInternalConstructor_AndInternalsVisibleToNotApplied();
+
+        [Fact]
+        public abstract Task ReturnsNoDiagnostic_WhenUsedForClassWithInternalConstructor_AndInternalsVisibleToApplied();
+
+        [Fact]
+        public abstract Task ReturnsNoDiagnostic_WhenUsedForClassWithProtectedInternalConstructor_AndInternalsVisibleToApplied();
+
         [Fact]
         public abstract Task ReturnsDiagnostic_WhenPassedParametersCount_GreaterThanCtorParametersCount();