Allow callback completion after ReturnAsync method

Abc-Arbitrage · Jun 11, 2022 · 102cb18 · 102cb18
1 parent 2a16700
commit 102cb18
Show file tree

Hide file tree

Showing 10 changed files with 161 additions and 1 deletion.
diff --git a/Abc.MoqComplete/Abc.MoqComplete.Tests/Completion/CallbackMethodProviderTests.cs b/Abc.MoqComplete/Abc.MoqComplete.Tests/Completion/CallbackMethodProviderTests.cs
@@ -12,6 +12,9 @@ public class CallbackMethodProviderTests: CodeCompletionTestBase
 
         [TestCase("callbackCompletion")]
         [TestCase("callbackCompletion_afterReturn")]
+        [TestCase("callbackCompletion_afterReturnAsync")]
+        [TestCase("callbackCompletion_afterReturnAsyncMultiple")]
+        [TestCase("callbackCompletion_afterReturnAsyncMultiple2")]
         [TestCase("callbackCompletion_generic")]
         public void should_fill_with_callback(string testSrc) => DoOneTest(testSrc);
     }

diff --git a/...lete/Abc.MoqComplete.Tests/data/CallbackCompletion/callbackCompletion_afterReturnAsync.cs b/...lete/Abc.MoqComplete.Tests/data/CallbackCompletion/callbackCompletion_afterReturnAsync.cs
@@ -0,0 +1,25 @@
+// ${COMPLETE_ITEM:Callback<int,string,bool>((i,toto,ok) => {\})}
+using Moq;
+using NUnit.Framework;
+using System.Threading.Tasks;
+
+namespace ConsoleApp1.Tests
+{
+    public interface ITestInterface
+    {
+        Task<int> BuildSomething(int i, string toto, bool ok);
+    }
+
+    [TestFixture]
+    public class Test1
+    {
+        [Test]
+        public void METHOD()
+        {
+            Mock<ITestInterface> temp = new Mock<ITestInterface>();
+            temp.Setup(x => x.BuildSomething(It.IsAny<int>(),It.IsAny<string>(), It.IsAny<bool>()))
+				.ReturnsAsync(0)
+                .c{caret}
+        }
+    }
+}
diff --git a/...Abc.MoqComplete.Tests/data/CallbackCompletion/callbackCompletion_afterReturnAsync.cs.gold b/...Abc.MoqComplete.Tests/data/CallbackCompletion/callbackCompletion_afterReturnAsync.cs.gold
@@ -0,0 +1,25 @@
+// ${COMPLETE_ITEM:Callback<int,string,bool>((i,toto,ok) => {\})}
+using Moq;
+using NUnit.Framework;
+using System.Threading.Tasks;
+
+namespace ConsoleApp1.Tests
+{
+    public interface ITestInterface
+    {
+        Task<int> BuildSomething(int i, string toto, bool ok);
+    }
+
+    [TestFixture]
+    public class Test1
+    {
+        [Test]
+        public void METHOD()
+        {
+            Mock<ITestInterface> temp = new Mock<ITestInterface>();
+            temp.Setup(x => x.BuildSomething(It.IsAny<int>(),It.IsAny<string>(), It.IsAny<bool>()))
+				.ReturnsAsync(0)
+                .Callback<int,string,bool>((i,toto,ok) => {{caret}})
+        }
+    }
+}
diff --git a/....MoqComplete.Tests/data/CallbackCompletion/callbackCompletion_afterReturnAsyncMultiple.cs b/....MoqComplete.Tests/data/CallbackCompletion/callbackCompletion_afterReturnAsyncMultiple.cs
@@ -0,0 +1,25 @@
+// ${COMPLETE_ITEM:Callback<int,string,bool>((i,toto,ok) => {\})}
+using Moq;
+using NUnit.Framework;
+using System.Threading.Tasks;
+
+namespace ConsoleApp1.Tests
+{
+    public interface ITestInterface
+    {
+        Task<int> BuildSomething(int i, string toto, bool ok);
+    }
+
+    [TestFixture]
+    public class Test1
+    {
+        [Test]
+        public void METHOD()
+        {
+            Mock<ITestInterface> temp = new Mock<ITestInterface>();
+            temp.Setup(x => x.BuildSomething(It.IsAny<int>(),It.IsAny<string>(), It.IsAny<bool>()))
+				.ReturnsAsync<int, string, bool, ITestInterface, int>((i, j, k) => 42)
+                .c{caret}
+        }
+    }
+}
diff --git a/...omplete.Tests/data/CallbackCompletion/callbackCompletion_afterReturnAsyncMultiple.cs.gold b/...omplete.Tests/data/CallbackCompletion/callbackCompletion_afterReturnAsyncMultiple.cs.gold
@@ -0,0 +1,25 @@
+// ${COMPLETE_ITEM:Callback<int,string,bool>((i,toto,ok) => {\})}
+using Moq;
+using NUnit.Framework;
+using System.Threading.Tasks;
+
+namespace ConsoleApp1.Tests
+{
+    public interface ITestInterface
+    {
+        Task<int> BuildSomething(int i, string toto, bool ok);
+    }
+
+    [TestFixture]
+    public class Test1
+    {
+        [Test]
+        public void METHOD()
+        {
+            Mock<ITestInterface> temp = new Mock<ITestInterface>();
+            temp.Setup(x => x.BuildSomething(It.IsAny<int>(),It.IsAny<string>(), It.IsAny<bool>()))
+				.ReturnsAsync<int, string, bool, ITestInterface, int>((i, j, k) => 42)
+                .Callback<int,string,bool>((i,toto,ok) => {{caret}})
+        }
+    }
+}
diff --git a/...MoqComplete.Tests/data/CallbackCompletion/callbackCompletion_afterReturnAsyncMultiple2.cs b/...MoqComplete.Tests/data/CallbackCompletion/callbackCompletion_afterReturnAsyncMultiple2.cs
@@ -0,0 +1,25 @@
+// ${COMPLETE_ITEM:Callback<int,string,bool>((i,toto,ok) => {\})}
+using Moq;
+using NUnit.Framework;
+using System.Threading.Tasks;
+
+namespace ConsoleApp1.Tests
+{
+    public interface ITestInterface
+    {
+        Task<int> BuildSomething(int i, string toto, bool ok);
+    }
+
+    [TestFixture]
+    public class Test1
+    {
+        [Test]
+        public void METHOD()
+        {
+            Mock<ITestInterface> temp = new Mock<ITestInterface>();
+            temp.Setup(x => x.BuildSomething(It.IsAny<int>(),It.IsAny<string>(), It.IsAny<bool>()))
+				.ReturnsAsync((int i, string j, bool k) => 42)
+                .c{caret}
+        }
+    }
+}
diff --git a/...mplete.Tests/data/CallbackCompletion/callbackCompletion_afterReturnAsyncMultiple2.cs.gold b/...mplete.Tests/data/CallbackCompletion/callbackCompletion_afterReturnAsyncMultiple2.cs.gold
@@ -0,0 +1,25 @@
+// ${COMPLETE_ITEM:Callback<int,string,bool>((i,toto,ok) => {\})}
+using Moq;
+using NUnit.Framework;
+using System.Threading.Tasks;
+
+namespace ConsoleApp1.Tests
+{
+    public interface ITestInterface
+    {
+        Task<int> BuildSomething(int i, string toto, bool ok);
+    }
+
+    [TestFixture]
+    public class Test1
+    {
+        [Test]
+        public void METHOD()
+        {
+            Mock<ITestInterface> temp = new Mock<ITestInterface>();
+            temp.Setup(x => x.BuildSomething(It.IsAny<int>(),It.IsAny<string>(), It.IsAny<bool>()))
+				.ReturnsAsync((int i, string j, bool k) => 42)
+                .Callback<int,string,bool>((i,toto,ok) => {{caret}})
+        }
+    }
+}
diff --git a/Abc.MoqComplete/Abc.MoqComplete/CompletionProvider/Callback/BaseCallbackMethodProvider.cs b/Abc.MoqComplete/Abc.MoqComplete/CompletionProvider/Callback/BaseCallbackMethodProvider.cs
@@ -56,7 +56,7 @@ protected override bool AddLookupItems(CSharpCodeCompletionContext context, IIte
 			var solution = context.BasicContext.Solution;
 			var methodIdentifier = solution.GetComponent<IMoqMethodIdentifier>();
 
-			if (methodIdentifier.IsMoqReturnMethod(invocation))
+			if (methodIdentifier.IsMoqReturnMethod(invocation) || methodIdentifier.IsMoqReturnAsyncMethod(invocation))
 			{
 				invocation = invocation.InvokedExpression?.FirstChild as IInvocationExpression;
 			}

diff --git a/Abc.MoqComplete/Abc.MoqComplete/Services/IMoqMethodIdentifier.cs b/Abc.MoqComplete/Abc.MoqComplete/Services/IMoqMethodIdentifier.cs
@@ -9,6 +9,7 @@ public interface IMoqMethodIdentifier
         bool IsMoqSetupMethod([CanBeNull]  IInvocationExpression invocationExpression);
         bool IsMoqVerifyMethod([CanBeNull]  IInvocationExpression invocationExpression);
         bool IsMoqReturnMethod([CanBeNull]  IInvocationExpression invocationExpression);
+        bool IsMoqReturnAsyncMethod([CanBeNull]  IInvocationExpression invocationExpression);
         bool IsMoqCallbackMethod([CanBeNull]  IInvocationExpression invocationExpression);
     }
 }
diff --git a/Abc.MoqComplete/Abc.MoqComplete/Services/MoqMethodIdentifier.cs b/Abc.MoqComplete/Abc.MoqComplete/Services/MoqMethodIdentifier.cs
@@ -36,6 +36,12 @@ public bool IsMoqReturnMethod(IInvocationExpression invocationExpression)
 					"Method:Moq.Language.IReturns`2.Returns",
 					"Method:Moq.Language.IReturns`1.Returns"));
 
+		public bool IsMoqReturnAsyncMethod(IInvocationExpression invocationExpression)
+			=> IsMethod(invocationExpression,
+				declaredElement => IsMethodStartingWithString(declaredElement,
+					"Method:Moq.GeneratedReturnsExtensions.ReturnsAsync(Moq.Language.IReturns`2",
+					"Method:Moq.ReturnsExtensions.ReturnsAsync(Moq.Language.IReturns`2"));
+
 		public bool IsMoqCallbackMethod(IInvocationExpression expression)
 			=> IsMethod(expression,
 				declaredElement => IsMethodStartingWithString(declaredElement,