GH-186 - SyncOverAsyncThrowsAnalyzer support for ThrowsAsync

nsubstitute · Jul 22, 2022 · 2166298 · 2166298
1 parent 97906f9
commit 2166298
Show file tree

Hide file tree

Showing 16 changed files with 414 additions and 7 deletions.
diff --git a/global.json b/global.json
@@ -1,5 +1,5 @@
 {
   "sdk": {
-    "version": "6.0.200"
+    "version": "6.0.300"
   }
 }
diff --git a/...ubstitute.Analyzers.Shared/CodeFixProviders/AbstractSyncOverAsyncThrowsCodeFixProvider.cs b/...ubstitute.Analyzers.Shared/CodeFixProviders/AbstractSyncOverAsyncThrowsCodeFixProvider.cs
@@ -45,7 +45,7 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
             return;
         }
 
-        var replacementMethod = methodSymbol.IsThrowsForAnyArgsMethod()
+        var replacementMethod = methodSymbol.IsThrowsSyncForAnyArgsMethod()
             ? "ReturnsForAnyArgs"
             : "Returns";
 
@@ -93,7 +93,7 @@ private async Task<SyntaxNode> CreateUpdatedInvocationExpression(
             CreateFromExceptionInvocationExpression(syntaxGenerator, invocationOperation);
 
         var returnsMethodName =
-            invocationSymbol.IsThrowsForAnyArgsMethod() ? "ReturnsForAnyArgs" : "Returns";
+            invocationSymbol.IsThrowsSyncForAnyArgsMethod() ? "ReturnsForAnyArgs" : "Returns";
 
         if (invocationSymbol.MethodKind == MethodKind.Ordinary)
         {

diff --git a/src/NSubstitute.Analyzers.Shared/DiagnosticAnalyzers/AbstractSyncOverAsyncThrowsAnalyzer.cs b/src/NSubstitute.Analyzers.Shared/DiagnosticAnalyzers/AbstractSyncOverAsyncThrowsAnalyzer.cs
@@ -42,7 +42,7 @@ private void AnalyzeInvocation(SyntaxNodeAnalysisContext syntaxNodeContext)
             return;
         }
 
-        if (!methodSymbol.IsThrowLikeMethod())
+        if (!methodSymbol.IsThrowSyncLikeMethod())
         {
             return;
         }

diff --git a/src/NSubstitute.Analyzers.Shared/Extensions/SubstituteSymbolExtensions.cs b/src/NSubstitute.Analyzers.Shared/Extensions/SubstituteSymbolExtensions.cs
@@ -42,7 +42,12 @@ public static bool IsThrowLikeMethod(this ISymbol symbol)
         return IsMember(symbol, MetadataNames.ThrowsMethodNames);
     }
 
-    public static bool IsThrowsForAnyArgsMethod(this ISymbol symbol)
+    public static bool IsThrowSyncLikeMethod(this ISymbol symbol)
+    {
+        return IsMember(symbol, MetadataNames.ThrowsSyncMethodNames);
+    }
+
+    public static bool IsThrowsSyncForAnyArgsMethod(this ISymbol symbol)
     {
         return IsMember(
             symbol,

diff --git a/src/NSubstitute.Analyzers.Shared/MetadataNames.cs b/src/NSubstitute.Analyzers.Shared/MetadataNames.cs
@@ -18,7 +18,9 @@ internal class MetadataNames
     public const string NSubstituteReturnsMethod = "Returns";
     public const string NSubstituteReturnsForAnyArgsMethod = "ReturnsForAnyArgs";
     public const string NSubstituteThrowsMethod = "Throws";
+    public const string NSubstituteThrowsAsyncMethod = "ThrowsAsync";
     public const string NSubstituteThrowsForAnyArgsMethod = "ThrowsForAnyArgs";
+    public const string NSubstituteThrowsAsyncForAnyArgsMethod = "ThrowsAsyncForAnyArgs";
     public const string NSubstituteAndDoesMethod = "AndDoes";
     public const string NSubstituteReturnsNullMethod = "ReturnsNull";
     public const string NSubstituteReturnsNullForAnyArgsMethod = "ReturnsNullForAnyArgs";
@@ -56,6 +58,14 @@ internal class MetadataNames
     };
 
     public static readonly IReadOnlyDictionary<string, string> ThrowsMethodNames = new Dictionary<string, string>
+    {
+        [NSubstituteThrowsMethod] = NSubstituteExceptionExtensionsFullTypeName,
+        [NSubstituteThrowsAsyncMethod] = NSubstituteExceptionExtensionsFullTypeName,
+        [NSubstituteThrowsForAnyArgsMethod] = NSubstituteExceptionExtensionsFullTypeName,
+        [NSubstituteThrowsAsyncForAnyArgsMethod] = NSubstituteExceptionExtensionsFullTypeName
+    };
+
+    public static readonly IReadOnlyDictionary<string, string> ThrowsSyncMethodNames = new Dictionary<string, string>
     {
         [NSubstituteThrowsMethod] = NSubstituteExceptionExtensionsFullTypeName,
         [NSubstituteThrowsForAnyArgsMethod] = NSubstituteExceptionExtensionsFullTypeName

diff --git a/...icAnalyzerTests/SyncOverAsyncThrowsAnalyzerTests/SyncOverAsyncThrowsDiagnosticVerifier.cs b/...icAnalyzerTests/SyncOverAsyncThrowsAnalyzerTests/SyncOverAsyncThrowsDiagnosticVerifier.cs
@@ -21,6 +21,15 @@ public static IEnumerable<object[]> ThrowsTestCases
         }
     }
 
+    public static IEnumerable<object[]> ThrowsAsyncTestCases
+    {
+        get
+        {
+            yield return new object[] { "ThrowsAsync" };
+            yield return new object[] { "ThrowsAsyncForAnyArgs" };
+        }
+    }
+
     protected DiagnosticDescriptor SyncOverAsyncThrowsDescriptor => DiagnosticDescriptors<DiagnosticDescriptorsProvider>.SyncOverAsyncThrows;
 
     protected override DiagnosticAnalyzer DiagnosticAnalyzer { get; } = new SyncOverAsyncThrowsAnalyzer();
@@ -40,4 +49,8 @@ public static IEnumerable<object[]> ThrowsTestCases
     [Theory]
     [MemberData(nameof(ThrowsTestCases))]
     public abstract Task ReportsNoDiagnostic_WhenUsedWithSyncMember(string method);
+
+    [Theory]
+    [MemberData(nameof(ThrowsAsyncTestCases))]
+    public abstract Task ReportsNoDiagnostic_WhenThrowsAsyncUsed(string method);
 }
diff --git a/.../DiagnosticAnalyzerTests/SyncOverAsyncThrowsAnalyzerTests/ThrowsAsExtensionMethodTests.cs b/.../DiagnosticAnalyzerTests/SyncOverAsyncThrowsAnalyzerTests/ThrowsAsExtensionMethodTests.cs
@@ -133,4 +133,51 @@ public void Test()
 
         await VerifyNoDiagnostic(source);
     }
+
+    public override async Task ReportsNoDiagnostic_WhenThrowsAsyncUsed(string method)
+    {
+        var source = $@"using System;
+using System.Threading.Tasks;
+using NSubstitute;
+using NSubstitute.ExceptionExtensions;
+
+namespace MyNamespace
+{{
+    public interface IFoo
+    {{
+        Task Bar();
+        Task<object> FooBar();
+
+        Task Foo {{ get; set; }}
+        Task<object> FooBarBar {{ get; set; }}
+
+        Task this[int x] {{ get; set; }}
+        Task<object> this[int x, int y] {{ get; set; }}
+    }}
+
+    public class FooTests
+    {{
+        public void Test()
+        {{
+            var substitute = NSubstitute.Substitute.For<IFoo>();
+            substitute.Bar().{method}(new Exception());
+            substitute.Bar().{method}(ex: new Exception());
+            substitute.FooBar().{method}(new Exception());
+            substitute.FooBar().{method}(ex: new Exception());
+
+            substitute.Foo.{method}(new Exception());
+            substitute.Foo.{method}(ex: new Exception());
+            substitute.FooBarBar.{method}(new Exception());
+            substitute.FooBarBar.{method}(ex: new Exception());
+
+            substitute[0].{method}(new Exception());
+            substitute[0].{method}(ex: new Exception());
+            substitute[0, 0].{method}(new Exception());
+            substitute[0, 0].{method}(ex: new Exception());
+        }}
+    }}
+}}";
+
+        await VerifyNoDiagnostic(source);
+    }
 }
diff --git a/.../SyncOverAsyncThrowsAnalyzerTests/ThrowsAsExtensionMethodWithGenericTypeSpecifiedTests.cs b/.../SyncOverAsyncThrowsAnalyzerTests/ThrowsAsExtensionMethodWithGenericTypeSpecifiedTests.cs
@@ -124,4 +124,51 @@ public void Test()
 
         await VerifyNoDiagnostic(source);
     }
+
+    public override async Task ReportsNoDiagnostic_WhenThrowsAsyncUsed(string method)
+    {
+        var source = $@"using System;
+using System.Threading.Tasks;
+using NSubstitute;
+using NSubstitute.ExceptionExtensions;
+
+namespace MyNamespace
+{{
+    public interface IFoo
+    {{
+        Task Bar();
+        Task<object> FooBar();
+
+        Task Foo {{ get; set; }}
+        Task<object> FooBarBar {{ get; set; }}
+
+        Task this[int x] {{ get; set; }}
+        Task<object> this[int x, int y] {{ get; set; }}
+    }}
+
+    public class FooTests
+    {{
+        public void Test()
+        {{
+            var substitute = NSubstitute.Substitute.For<IFoo>();
+            substitute.Bar().{method}<Exception>();
+            substitute.Bar().{method}<Exception>();
+            substitute.FooBar().{method}<Exception>();
+            substitute.FooBar().{method}<Exception>();
+
+            substitute.Foo.{method}<Exception>();
+            substitute.Foo.{method}<Exception>();
+            substitute.FooBarBar.{method}<Exception>();
+            substitute.FooBarBar.{method}<Exception>();
+
+            substitute[0].{method}<Exception>();
+            substitute[0].{method}<Exception>();
+            substitute[0, 0].{method}<Exception>();
+            substitute[0, 0].{method}<Exception>();
+        }}
+    }}
+}}";
+
+        await VerifyNoDiagnostic(source);
+    }
 }
diff --git a/...p/DiagnosticAnalyzerTests/SyncOverAsyncThrowsAnalyzerTests/ThrowsAsOrdinaryMethodTests.cs b/...p/DiagnosticAnalyzerTests/SyncOverAsyncThrowsAnalyzerTests/ThrowsAsOrdinaryMethodTests.cs
@@ -142,4 +142,57 @@ public void Test()
 
         await VerifyNoDiagnostic(source);
     }
+
+    public override async Task ReportsNoDiagnostic_WhenThrowsAsyncUsed(string method)
+    {
+        var source = $@"using System;
+using System.Threading.Tasks;
+using NSubstitute;
+using NSubstitute.ExceptionExtensions;
+
+namespace MyNamespace
+{{
+    public interface IFoo
+    {{
+        Task Bar();
+        Task<object> FooBar();
+
+        Task Foo {{ get; set; }}
+        Task<object> FooBarBar {{ get; set; }}
+
+        Task this[int x] {{ get; set; }}
+        Task<object> this[int x, int y] {{ get; set; }}
+    }}
+
+    public class FooTests
+    {{
+        public void Test()
+        {{
+            var substitute = NSubstitute.Substitute.For<IFoo>();
+            ExceptionExtensions.{method}(substitute.Bar(), new Exception());
+            ExceptionExtensions.{method}(value: substitute.Bar(), ex: new Exception());
+            ExceptionExtensions.{method}(ex: new Exception(), value: substitute.Bar());
+            ExceptionExtensions.{method}(substitute.FooBar(), new Exception());
+            ExceptionExtensions.{method}(value: substitute.FooBar(), ex: new Exception());
+            ExceptionExtensions.{method}(ex: new Exception(), value: substitute.FooBar());
+
+            ExceptionExtensions.{method}(substitute.Foo, new Exception());
+            ExceptionExtensions.{method}(value: substitute.Foo, ex: new Exception());
+            ExceptionExtensions.{method}(ex: new Exception(), value: substitute.Foo);
+            ExceptionExtensions.{method}(substitute.FooBarBar, new Exception());
+            ExceptionExtensions.{method}(value: substitute.FooBarBar, ex: new Exception());
+            ExceptionExtensions.{method}(ex: new Exception(), value: substitute.FooBarBar);
+
+            ExceptionExtensions.{method}(substitute[0], new Exception());
+            ExceptionExtensions.{method}(value: substitute[0], ex: new Exception());
+            ExceptionExtensions.{method}(ex: new Exception(), value: substitute[0]);
+            ExceptionExtensions.{method}(substitute[0, 0], new Exception());
+            ExceptionExtensions.{method}(value: substitute[0, 0], ex: new Exception());
+            ExceptionExtensions.{method}(ex: new Exception(), value: substitute[0, 0]);
+        }}
+    }}
+}}";
+
+        await VerifyNoDiagnostic(source);
+    }
 }
diff --git a/...s/SyncOverAsyncThrowsAnalyzerTests/ThrowsAsOrdinaryMethodWithGenericTypeSpecifiedTests.cs b/...s/SyncOverAsyncThrowsAnalyzerTests/ThrowsAsOrdinaryMethodWithGenericTypeSpecifiedTests.cs
@@ -133,4 +133,51 @@ public void Test()
 
         await VerifyNoDiagnostic(source);
     }
+
+    public override async Task ReportsNoDiagnostic_WhenThrowsAsyncUsed(string method)
+    {
+        var source = $@"using System;
+using System.Threading.Tasks;
+using NSubstitute;
+using NSubstitute.ExceptionExtensions;
+
+namespace MyNamespace
+{{
+    public interface IFoo
+    {{
+        Task Bar();
+        Task<object> FooBar();
+
+        Task Foo {{ get; set; }}
+        Task<object> FooBarBar {{ get; set; }}
+
+        Task this[int x] {{ get; set; }}
+        Task<object> this[int x, int y] {{ get; set; }}
+    }}
+
+    public class FooTests
+    {{
+        public void Test()
+        {{
+            var substitute = NSubstitute.Substitute.For<IFoo>();
+            ExceptionExtensions.{method}<Exception>(substitute.Bar());
+            ExceptionExtensions.{method}<Exception>(value: substitute.Bar());
+            ExceptionExtensions.{method}<Exception>(substitute.FooBar());
+            ExceptionExtensions.{method}<Exception>(value: substitute.FooBar());
+
+            ExceptionExtensions.{method}<Exception>(substitute.Foo);
+            ExceptionExtensions.{method}<Exception>(value: substitute.Foo);
+            ExceptionExtensions.{method}<Exception>(substitute.FooBarBar);
+            ExceptionExtensions.{method}<Exception>(value: substitute.FooBarBar);
+
+            ExceptionExtensions.{method}<Exception>(substitute[0]);
+            ExceptionExtensions.{method}<Exception>(value: substitute[0]);
+            ExceptionExtensions.{method}<Exception>(substitute[0, 0]);
+            ExceptionExtensions.{method}<Exception>(value: substitute[0, 0]);
+        }}
+    }}
+}}";
+
+        await VerifyNoDiagnostic(source);
+    }
 }
diff --git a/...tute.Analyzers.Tests.Shared/DiagnosticAnalyzers/ISyncOverAsyncThrowsDiagnosticVerifier.cs b/...tute.Analyzers.Tests.Shared/DiagnosticAnalyzers/ISyncOverAsyncThrowsDiagnosticVerifier.cs
@@ -11,4 +11,6 @@ public interface ISyncOverAsyncThrowsDiagnosticVerifier
     Task ReportsDiagnostic_WhenUsedInTaskReturningIndexer(string method);
 
     Task ReportsNoDiagnostic_WhenUsedWithSyncMember(string method);
+
+    Task ReportsNoDiagnostic_WhenThrowsAsyncUsed(string method);
 }
diff --git a/...cAnalyzersTests/SyncOverAsyncThrowsAnalyzerTests/SyncOverAsyncThrowsDiagnosticVerifier.cs b/...cAnalyzersTests/SyncOverAsyncThrowsAnalyzerTests/SyncOverAsyncThrowsDiagnosticVerifier.cs
@@ -21,6 +21,15 @@ public static IEnumerable<object[]> ThrowsTestCases
         }
     }
 
+    public static IEnumerable<object[]> ThrowsAsyncTestCases
+    {
+        get
+        {
+            yield return new object[] { "ThrowsAsync" };
+            yield return new object[] { "ThrowsAsyncForAnyArgs" };
+        }
+    }
+
     protected DiagnosticDescriptor SyncOverAsyncThrowsDescriptor => DiagnosticDescriptors<DiagnosticDescriptorsProvider>.SyncOverAsyncThrows;
 
     protected override DiagnosticAnalyzer DiagnosticAnalyzer { get; } = new SyncOverAsyncThrowsAnalyzer();
@@ -40,4 +49,8 @@ public static IEnumerable<object[]> ThrowsTestCases
     [Theory]
     [MemberData(nameof(ThrowsTestCases))]
     public abstract Task ReportsNoDiagnostic_WhenUsedWithSyncMember(string method);
+
+    [Theory]
+    [MemberData(nameof(ThrowsAsyncTestCases))]
+    public abstract Task ReportsNoDiagnostic_WhenThrowsAsyncUsed(string method);
 }