Improve the fixer PosInfoMoq1000 to add a new line for the first VerifyAll() if need.

Author: GillesTourreau

src/Moq.Analyzers/CodeFixes/AddVerifyAllCodeFixProvider.cs

@@ -92,6 +92,7 @@ private static async Task<Document> AddVerifyAllAsync(Document document, MethodD
 
             // Find the location where we can insert the mock.
             var index = oldUnitTestMethod.Body.Statements.Count;
+            bool insertNewLine = true;
 
             foreach (var statement in oldUnitTestMethod.Body.Statements.Reverse())
             {
@@ -105,6 +106,8 @@ private static async Task<Document> AddVerifyAllAsync(Document document, MethodD
                     break;
                 }
 
+                insertNewLine = false;
+
                 if (variableName.CompareTo(otherVariableName) >= 0)
                 {
                     // The variable name to add is in alphabetic order after the "variable.VerifyAll()",
@@ -123,11 +126,7 @@ private static async Task<Document> AddVerifyAllAsync(Document document, MethodD
                         SyntaxFactory.IdentifierName(variableName),
                         SyntaxFactory.IdentifierName("VerifyAll"))));
 
-            var oldBodyStatements = oldUnitTestMethod.Body.Statements;
-
-            var newStatements = InsertStatement(oldBodyStatements, index, verifyAllCallStatement);
-
-            var newUnitTestMethod = oldUnitTestMethod.WithBody(oldUnitTestMethod.Body.WithStatements(newStatements));
+            var newUnitTestMethodBody = InsertStatement(oldUnitTestMethod.Body, index, verifyAllCallStatement, insertNewLine);
 
             var oldRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 
@@ -136,28 +135,39 @@ private static async Task<Document> AddVerifyAllAsync(Document document, MethodD
                 return document;
             }
 
-            var newRoot = oldRoot.ReplaceNode(oldUnitTestMethod, newUnitTestMethod);
+            var newRoot = oldRoot.ReplaceNode(oldUnitTestMethod, oldUnitTestMethod.WithBody(newUnitTestMethodBody));
 
             return document.WithSyntaxRoot(newRoot);
         }
 
-        private static SyntaxList<StatementSyntax> InsertStatement(SyntaxList<StatementSyntax> list, int index, StatementSyntax statement)
+        private static BlockSyntax InsertStatement(BlockSyntax unitTestMethodBody, int index, StatementSyntax statement, bool insertNewLine)
         {
-            var newStatements = new List<StatementSyntax>(list);
+            var newStatements = new List<StatementSyntax>(unitTestMethodBody.Statements);
 
             if (index < newStatements.Count)
             {
                 var leadingTrivia = newStatements[index].GetLeadingTrivia();
 
-                // Remove the leading trivia of the current node.
+                // Remove the leading trivia of the current node and transfert it to the new statement to insert.
                 newStatements[index] = newStatements[index].ReplaceNode(newStatements[index], newStatements[index].WithoutLeadingTrivia());
 
                 statement = statement.WithLeadingTrivia(leadingTrivia);
             }
 
+            if (insertNewLine)
+            {
+                // Special case, we insert a new line at the end of the unit test (we also retrieve the comment at the end if need).
+                // Because we want that the VerifyAll() blocks are detached with a new line.
+                // It is useful if developers want to call the fixer for all the solution.
+                statement = statement.WithLeadingTrivia(
+                    unitTestMethodBody.CloseBraceToken.LeadingTrivia.Add(SyntaxFactory.CarriageReturnLineFeed));
+
+                unitTestMethodBody = unitTestMethodBody.WithCloseBraceToken(unitTestMethodBody.CloseBraceToken.WithLeadingTrivia());
+            }
+
             newStatements.Insert(index, statement);
 
-            return SyntaxFactory.List(newStatements);
+            return unitTestMethodBody.WithStatements(SyntaxFactory.List(newStatements));
         }
 
         private static bool IsVerifyAll(SemanticModel semanticModel, MoqSymbols moqSymbols, ExpressionStatementSyntax statement, out string? variableName, CancellationToken cancellationToken)

tests/Moq.Analyzers.Tests/CodeFixes/AddVerifyAllCodeFixProviderTest.cs

@@ -71,6 +71,76 @@ public void TestMethod()
         }
     }
 
+    public interface I
+    {
+        void Method();
+    }
+}";
+
+            await Verifier.VerifyCodeFixAsync(source, expectedFixedSource);
+        }
+
+        [Fact]
+        public async Task AddVerifyAllInTheMiddleOfOtherMocks_Fix()
+        {
+            var source = @"
+namespace ConsoleApplication1
+{
+    using Moq;
+    using System;
+
+    public class TestClass
+    {
+        public void TestMethod()
+        {
+            var mock1 = new Mock<I>();
+            mock1.Setup(i => i.Method());
+
+            var mock2 = {|PosInfoMoq1000:new Mock<I>()|};
+            mock2.Setup(i => i.Method());
+
+            var mock3 = new Mock<I>();
+            mock3.Setup(i => i.Method());
+
+            // No changes
+            mock1.VerifyAll();
+            mock3.VerifyAll();
+        }
+    }
+
+    public interface I
+    {
+        void Method();
+    }
+}";
+
+            var expectedFixedSource =
+            @"
+namespace ConsoleApplication1
+{
+    using Moq;
+    using System;
+
+    public class TestClass
+    {
+        public void TestMethod()
+        {
+            var mock1 = new Mock<I>();
+            mock1.Setup(i => i.Method());
+
+            var mock2 = new Mock<I>();
+            mock2.Setup(i => i.Method());
+
+            var mock3 = new Mock<I>();
+            mock3.Setup(i => i.Method());
+
+            // No changes
+            mock1.VerifyAll();
+            mock2.VerifyAll();
+            mock3.VerifyAll();
+        }
+    }
+
     public interface I
     {
         void Method();
@@ -151,7 +221,58 @@ public interface I
         }
 
         [Fact]
-        public async Task AddVerifyAllSingleMock_WithComment_Fix()
+        public async Task AddVerifyAllSingleMock()
+        {
+            var source = @"
+namespace ConsoleApplication1
+{
+    using Moq;
+    using System;
+
+    public class TestClass
+    {
+        public void TestMethod()
+        {
+            var mock1 = {|PosInfoMoq1000:new Mock<I>()|};
+            mock1.Setup(i => i.Method());
+        }
+    }
+
+    public interface I
+    {
+        void Method();
+    }
+}";
+
+            var expectedFixedSource =
+            @"
+namespace ConsoleApplication1
+{
+    using Moq;
+    using System;
+
+    public class TestClass
+    {
+        public void TestMethod()
+        {
+            var mock1 = new Mock<I>();
+            mock1.Setup(i => i.Method());
+
+            mock1.VerifyAll();
+        }
+    }
+
+    public interface I
+    {
+        void Method();
+    }
+}";
+
+            await Verifier.VerifyCodeFixAsync(source, expectedFixedSource);
+        }
+
+        [Fact]
+        public async Task AddVerifyAllSingleMock_WithCommentAtTheEnd()
         {
             var source = @"
 namespace ConsoleApplication1
@@ -165,6 +286,8 @@ public void TestMethod()
         {
             var mock1 = {|PosInfoMoq1000:new Mock<I>()|};
             mock1.Setup(i => i.Method());
+
+            // End of unit tests
         }
     }
 
@@ -187,6 +310,9 @@ public void TestMethod()
         {
             var mock1 = new Mock<I>();
             mock1.Setup(i => i.Method());
+
+            // End of unit tests
+
             mock1.VerifyAll();
         }
     }