Merge pull request #182 from nsubstitute/GH-181-received-in-received-…

…in-order-code-fix

GH-181 - code fix provider for NS5001

src/NSubstitute.Analyzers.CSharp/CodeFixProviders/ReceivedInReceivedInOrderCodeFixProvider.cs

@@ -0,0 +1,10 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeFixes;
+using NSubstitute.Analyzers.Shared.CodeFixProviders;
+
+namespace NSubstitute.Analyzers.CSharp.CodeFixProviders;
+
+[ExportCodeFixProvider(LanguageNames.CSharp)]
+internal sealed class ReceivedInReceivedInOrderCodeFixProvider : AbstractReceivedInReceivedInOrderCodeFixProvider
+{
+}

src/NSubstitute.Analyzers.Shared/CodeFixProviders/AbstractReceivedInReceivedInOrderCodeFixProvider.cs

@@ -0,0 +1,53 @@
+using System.Collections.Immutable;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.Operations;
+using Document = Microsoft.CodeAnalysis.Document;
+
+namespace NSubstitute.Analyzers.Shared.CodeFixProviders;
+
+internal abstract class AbstractReceivedInReceivedInOrderCodeFixProvider : CodeFixProvider
+{
+    public override FixAllProvider GetFixAllProvider() => WellKnownFixAllProviders.BatchFixer;
+
+    public override ImmutableArray<string> FixableDiagnosticIds { get; } = ImmutableArray.Create(DiagnosticIdentifiers.ReceivedUsedInReceivedInOrder);
+
+    public override Task RegisterCodeFixesAsync(CodeFixContext context)
+    {
+        var diagnostic = context.Diagnostics.FirstOrDefault(diag => diag.Descriptor.Id == DiagnosticIdentifiers.ReceivedUsedInReceivedInOrder);
+        if (diagnostic != null)
+        {
+            var codeAction = CodeAction.Create("Remove redundant Received checks", ct => CreateChangedDocument(ct, context, diagnostic), nameof(AbstractReceivedInReceivedInOrderCodeFixProvider));
+            context.RegisterCodeFix(codeAction, diagnostic);
+        }
+
+        return Task.CompletedTask;
+    }
+
+    private async Task<Document> CreateChangedDocument(CancellationToken cancellationToken, CodeFixContext context, Diagnostic diagnostic)
+    {
+        var root = await context.Document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+
+        var invocation = root.FindNode(diagnostic.Location.SourceSpan, getInnermostNodeForTie: true);
+
+        var semanticModel = await context.Document.GetSemanticModelAsync(cancellationToken);
+        if (semanticModel.GetOperation(invocation) is not IInvocationOperation invocationOperation)
+        {
+            return context.Document;
+        }
+
+        var syntax = invocationOperation.Instance != null
+            ? invocationOperation.Instance.Syntax
+            : invocationOperation.Arguments.Single(arg => arg.Parameter.Ordinal == 0).Value.Syntax;
+
+        var updatedRoot = root.ReplaceNode(
+            invocation,
+            syntax.WithTriviaFrom(invocation));
+
+        return context.Document.WithSyntaxRoot(updatedRoot);
+    }
+}

src/NSubstitute.Analyzers.VisualBasic/CodeFixProviders/ReceivedInReceivedInOrderCodeFixProvider.cs

@@ -0,0 +1,10 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeFixes;
+using NSubstitute.Analyzers.Shared.CodeFixProviders;
+
+namespace NSubstitute.Analyzers.VisualBasic.CodeFixProviders;
+
+[ExportCodeFixProvider(LanguageNames.VisualBasic)]
+internal sealed class ReceivedInReceivedInOrderCodeFixProvider : AbstractReceivedInReceivedInOrderCodeFixProvider
+{
+}

tests/NSubstitute.Analyzers.Tests.CSharp/CodeFixProviderTests/ReceivedInReceivedInOrderCodeFixProviderTests/ReceivedAsExtensionMethodTests.cs

@@ -0,0 +1,119 @@
+using System.Threading.Tasks;
+using Xunit;
+
+namespace NSubstitute.Analyzers.Tests.CSharp.CodeFixProviderTests.ReceivedInReceivedInOrderCodeFixProviderTests;
+
+public class ReceivedAsExtensionMethodTests : ReceivedInReceivedInOrderCodeFixVerifier
+{
+    [Fact]
+    public override async Task RemovesReceivedChecks_WhenReceivedChecksHasNoArguments()
+    {
+        var oldSource = @"using NSubstitute;
+using NSubstitute.ReceivedExtensions;
+
+namespace MyNamespace
+{
+    public interface IFoo
+    {
+        int Bar();
+        int Bar(int x);
+    }
+
+    public class FooTests
+    {
+        public void Test()
+        {
+            var substitute = NSubstitute.Substitute.For<IFoo>();
+            Received.InOrder(() =>
+            { 
+                substitute.Received().Bar();
+                substitute.Received().Bar(Arg.Any<int>());
+                substitute.ReceivedWithAnyArgs().Bar(Arg.Any<int>());
+            });
+        }
+    }
+}";
+
+        var newSource = @"using NSubstitute;
+using NSubstitute.ReceivedExtensions;
+
+namespace MyNamespace
+{
+    public interface IFoo
+    {
+        int Bar();
+        int Bar(int x);
+    }
+
+    public class FooTests
+    {
+        public void Test()
+        {
+            var substitute = NSubstitute.Substitute.For<IFoo>();
+            Received.InOrder(() =>
+            { 
+                substitute.Bar();
+                substitute.Bar(Arg.Any<int>());
+                substitute.Bar(Arg.Any<int>());
+            });
+        }
+    }
+}";
+        await VerifyFix(oldSource, newSource);
+    }
+
+    [Fact]
+    public override async Task RemovesReceivedChecks_WhenReceivedChecksHasArguments()
+    {
+        var oldSource = @"using NSubstitute;
+using NSubstitute.ReceivedExtensions;
+
+namespace MyNamespace
+{
+    public interface IFoo
+    {
+        int Bar();
+        int Bar(int x);
+    }
+
+    public class FooTests
+    {
+        public void Test()
+        {
+            var substitute = NSubstitute.Substitute.For<IFoo>();
+            Received.InOrder(() =>
+            { 
+                substitute.Received(1).Bar();
+                substitute.Received(1).Bar(Arg.Any<int>());
+            });
+        }
+    }
+}";
+
+        var newSource = @"using NSubstitute;
+using NSubstitute.ReceivedExtensions;
+
+namespace MyNamespace
+{
+    public interface IFoo
+    {
+        int Bar();
+        int Bar(int x);
+    }
+
+    public class FooTests
+    {
+        public void Test()
+        {
+            var substitute = NSubstitute.Substitute.For<IFoo>();
+            Received.InOrder(() =>
+            { 
+                substitute.Bar();
+                substitute.Bar(Arg.Any<int>());
+            });
+        }
+    }
+}";
+        await VerifyFix(oldSource, newSource);
+    }
+}

tests/NSubstitute.Analyzers.Tests.CSharp/CodeFixProviderTests/ReceivedInReceivedInOrderCodeFixProviderTests/ReceivedAsOrdinaryMethodTests.cs

@@ -0,0 +1,119 @@
+using System.Threading.Tasks;
+using Xunit;
+
+namespace NSubstitute.Analyzers.Tests.CSharp.CodeFixProviderTests.ReceivedInReceivedInOrderCodeFixProviderTests;
+
+public class ReceivedAsOrdinaryMethodTests : ReceivedInReceivedInOrderCodeFixVerifier
+{
+    [Fact]
+    public override async Task RemovesReceivedChecks_WhenReceivedChecksHasNoArguments()
+    {
+        var oldSource = @"using NSubstitute;
+using NSubstitute.ReceivedExtensions;
+
+namespace MyNamespace
+{
+    public interface IFoo
+    {
+        int Bar();
+        int Bar(int x);
+    }
+
+    public class FooTests
+    {
+        public void Test()
+        {
+            var substitute = NSubstitute.Substitute.For<IFoo>();
+            Received.InOrder(() =>
+            { 
+                SubstituteExtensions.Received(substitute).Bar();
+                SubstituteExtensions.Received(substitute).Bar(Arg.Any<int>());
+                SubstituteExtensions.ReceivedWithAnyArgs(substitute).Bar(Arg.Any<int>());
+            });
+        }
+    }
+}";
+
+        var newSource = @"using NSubstitute;
+using NSubstitute.ReceivedExtensions;
+
+namespace MyNamespace
+{
+    public interface IFoo
+    {
+        int Bar();
+        int Bar(int x);
+    }
+
+    public class FooTests
+    {
+        public void Test()
+        {
+            var substitute = NSubstitute.Substitute.For<IFoo>();
+            Received.InOrder(() =>
+            { 
+                substitute.Bar();
+                substitute.Bar(Arg.Any<int>());
+                substitute.Bar(Arg.Any<int>());
+            });
+        }
+    }
+}";
+        await VerifyFix(oldSource, newSource);
+    }
+
+    [Fact]
+    public override async Task RemovesReceivedChecks_WhenReceivedChecksHasArguments()
+    {
+        var oldSource = @"using NSubstitute;
+using NSubstitute.ReceivedExtensions;
+
+namespace MyNamespace
+{
+    public interface IFoo
+    {
+        int Bar();
+        int Bar(int x);
+    }
+
+    public class FooTests
+    {
+        public void Test()
+        {
+            var substitute = NSubstitute.Substitute.For<IFoo>();
+            Received.InOrder(() =>
+            { 
+                SubstituteExtensions.Received(substitute, 1).Bar();
+                SubstituteExtensions.Received(substitute, 1).Bar(Arg.Any<int>());
+            });
+        }
+    }
+}";
+
+        var newSource = @"using NSubstitute;
+using NSubstitute.ReceivedExtensions;
+
+namespace MyNamespace
+{
+    public interface IFoo
+    {
+        int Bar();
+        int Bar(int x);
+    }
+
+    public class FooTests
+    {
+        public void Test()
+        {
+            var substitute = NSubstitute.Substitute.For<IFoo>();
+            Received.InOrder(() =>
+            { 
+                substitute.Bar();
+                substitute.Bar(Arg.Any<int>());
+            });
+        }
+    }
+}";
+        await VerifyFix(oldSource, newSource);
+    }
+}

tests/NSubstitute.Analyzers.Tests.CSharp/CodeFixProviderTests/ReceivedInReceivedInOrderCodeFixProviderTests/ReceivedInReceivedInOrderCodeFixVerifier.cs

@@ -0,0 +1,20 @@
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.Diagnostics;
+using NSubstitute.Analyzers.CSharp.CodeFixProviders;
+using NSubstitute.Analyzers.CSharp.DiagnosticAnalyzers;
+using NSubstitute.Analyzers.Shared.CodeFixProviders;
+using NSubstitute.Analyzers.Tests.Shared.CodeFixProviders;
+
+namespace NSubstitute.Analyzers.Tests.CSharp.CodeFixProviderTests.ReceivedInReceivedInOrderCodeFixProviderTests;
+
+public abstract class ReceivedInReceivedInOrderCodeFixVerifier : CSharpCodeFixVerifier, IReceivedInReceivedInOrderCodeFixVerifier
+{
+    protected override DiagnosticAnalyzer DiagnosticAnalyzer { get; } = new ReceivedInReceivedInOrderAnalyzer();
+
+    protected override CodeFixProvider CodeFixProvider { get; } = new ReceivedInReceivedInOrderCodeFixProvider();
+
+    public abstract Task RemovesReceivedChecks_WhenReceivedChecksHasNoArguments();
+
+    public abstract Task RemovesReceivedChecks_WhenReceivedChecksHasArguments();
+}

tests/NSubstitute.Analyzers.Tests.Shared/CodeFixProviders/IReceivedInReceivedInOrderCodeFixVerifier.cs

@@ -0,0 +1,10 @@
+using System.Threading.Tasks;
+
+namespace NSubstitute.Analyzers.Tests.Shared.CodeFixProviders;
+
+public interface IReceivedInReceivedInOrderCodeFixVerifier
+{
+    Task RemovesReceivedChecks_WhenReceivedChecksHasNoArguments();
+
+    Task RemovesReceivedChecks_WhenReceivedChecksHasArguments();
+}