check if method is async and await results, #199 (#201)

* check if method is async and await results, #199 Signed-off-by: sriv <[email protected]> * Add .NET 8 support (#200) * Add .NET 8 support Signed-off-by: Martin Pekurny <[email protected]> * Update the init command to create a newer csproj file and removed the matrix for different dotnet versions in the build.yml Signed-off-by: Martin Pekurny <[email protected]> * Limiting the number of nodes to use for the feature tests Signed-off-by: Martin Pekurny <[email protected]> --------- Signed-off-by: Martin Pekurny <[email protected]> Signed-off-by: sriv <[email protected]> * add check to guard against async void impl step implementations with async void are treated as not implemented Signed-off-by: sriv <[email protected]> * bump version 0.6.0 Signed-off-by: sriv <[email protected]> * fix nunit assert syntax Signed-off-by: sriv <[email protected]> * make MethodExecutor.Execute handle async, #199 the entire method execution chain is now async Signed-off-by: sriv <[email protected]> * preserve arguments check when executing hook Signed-off-by: sriv <[email protected]> --------- Signed-off-by: sriv <[email protected]> Signed-off-by: Martin Pekurny <[email protected]> Co-authored-by: mpekurny <[email protected]>
getgauge · Feb 6, 2024 · b7550c9 · b7550c9
1 parent 92efd92
commit b7550c9
Show file tree

Hide file tree

Showing 53 changed files with 374 additions and 219 deletions.
diff --git a/.gitignore b/.gitignore
@@ -7,4 +7,9 @@ deploy
 artifacts
 .ionide
 .DS_Store
-.fake
+.fake
+.idea
+Gauge.Dotnet.sln.DotSettings.user
+_testdata/Sample/.gauge/
+_testdata/Sample/logs/
+_testdata/Sample/reports/
diff --git a/README.MD b/README.MD
@@ -37,15 +37,15 @@ gauge run specs
 #### Install specific version
 
 ```
-gauge install dotnet --version 0.5.2
+gauge install dotnet --version 0.6.0
 ```
 
 #### Offline installation
 
 Download the plugin from [Releases](https://github.com/getgauge/gauge-dotnet/releases)
 
 ```
-gauge install dotnet --file gauge-dotnet-0.5.2.zip
+gauge install dotnet --file gauge-dotnet-0.6.0.zip
 ```
 
 #### Build from Source

diff --git a/_testdata/Sample/IntegrationTestSample.csproj b/_testdata/Sample/IntegrationTestSample.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>

diff --git a/_testdata/Sample/StepImplementation.cs b/_testdata/Sample/StepImplementation.cs
@@ -30,6 +30,14 @@ public void SaySomething(string what, string who)
             GaugeMessages.WriteMessage("{0}, {1}!", what, who);
         }
 
+        [Step("Say <what> to <who> async")]
+        public async Task SaySomethingAsync(string what, string who)
+        {
+            Console.WriteLine("{0}, {1}!", what, who);
+            GaugeMessages.WriteMessage("{0}, {1}!", what, who);
+            await Task.Delay(100);
+        }
+
         [Step("I throw an unserializable exception")]
         public void ThrowUnserializableException()
         {

diff --git a/_testdata/Sample/gauge_bin/IntegrationTestSample.deps.json b/_testdata/Sample/gauge_bin/IntegrationTestSample.deps.json
@@ -1,11 +1,12 @@
 {
   "runtimeTarget": {
-    "name": ".NETCoreApp,Version=v3.0",
+    "name": ".NETCoreApp,Version=v7.0/linux-x64",
     "signature": ""
   },
   "compilationOptions": {},
   "targets": {
-    ".NETCoreApp,Version=v3.0": {
+    ".NETCoreApp,Version=v7.0": {},
+    ".NETCoreApp,Version=v7.0/linux-x64": {
       "IntegrationTestSample/1.0.0": {
         "dependencies": {
           "Gauge.CSharp.Lib": "0.7.6"

diff --git a/_testdata/Sample/gauge_bin/IntegrationTestSample.dll b/_testdata/Sample/gauge_bin/IntegrationTestSample.dll
diff --git a/_testdata/Sample/gauge_bin/IntegrationTestSample.pdb b/_testdata/Sample/gauge_bin/IntegrationTestSample.pdb
diff --git a/integration-test/ExecuteStepProcessorTests.cs b/integration-test/ExecuteStepProcessorTests.cs
@@ -6,6 +6,7 @@
 
 
 using System.Threading;
+using System.Threading.Tasks;
 using Gauge.Dotnet.Models;
 using Gauge.Dotnet.Processors;
 using Gauge.Dotnet.Wrappers;
@@ -18,7 +19,7 @@ namespace Gauge.Dotnet.IntegrationTests
     public class ExecuteStepProcessorTests : IntegrationTestsBase
     {
         [Test]
-        public void ShouldExecuteMethodFromRequest()
+        public async Task ShouldExecuteMethodFromRequest()
         {
             const string parameterizedStepText = "Step that takes a table {}";
             const string stepText = "Step that takes a table <table>";
@@ -64,15 +65,15 @@ public void ShouldExecuteMethodFromRequest()
                         }
                     }
             };
-            var result = executeStepProcessor.Process(message);
+            var result = await executeStepProcessor.Process(message);
 
             var protoExecutionResult = result.ExecutionResult;
             ClassicAssert.IsNotNull(protoExecutionResult);
             ClassicAssert.IsFalse(protoExecutionResult.Failed);
         }
 
         [Test]
-        public void ShouldCaptureScreenshotOnFailure()
+        public async Task ShouldCaptureScreenshotOnFailure()
         {
             const string stepText = "I throw a serializable exception";
             var reflectionWrapper = new ReflectionWrapper();
@@ -96,7 +97,7 @@ public void ShouldCaptureScreenshotOnFailure()
                 ActualStepText = stepText
             };
 
-            var result = executeStepProcessor.Process(message);
+            var result = await executeStepProcessor.Process(message);
             var protoExecutionResult = result.ExecutionResult;
 
             ClassicAssert.IsNotNull(protoExecutionResult);

diff --git a/integration-test/ExecutionOrchestratorTests.cs b/integration-test/ExecutionOrchestratorTests.cs
@@ -7,6 +7,7 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using Gauge.CSharp.Lib;
 using Gauge.Dotnet.Models;
 using Gauge.Dotnet.Wrappers;
@@ -19,7 +20,7 @@ namespace Gauge.Dotnet.IntegrationTests
     public class ExecutionOrchestratorTests : IntegrationTestsBase
     {
         [Test]
-        public void RecoverableIsTrueOnExceptionThrownWhenContinueOnFailure()
+        public async Task RecoverableIsTrueOnExceptionThrownWhenContinueOnFailure()
         {
             var reflectionWrapper = new ReflectionWrapper();
             var activatorWrapper = new ActivatorWrapper();
@@ -33,13 +34,13 @@ public void RecoverableIsTrueOnExceptionThrownWhenContinueOnFailure()
                 new StepExecutor(assemblyLoader, reflectionWrapper, classInstanceManager));
             var gaugeMethod = assemblyLoader.GetStepRegistry()
                 .MethodFor("I throw a serializable exception and continue");
-            var executionResult = orchestrator.ExecuteStep(gaugeMethod);
+            var executionResult = await orchestrator.ExecuteStep(gaugeMethod);
             ClassicAssert.IsTrue(executionResult.Failed);
             ClassicAssert.IsTrue(executionResult.RecoverableError);
         }
 
         [Test]
-        public void ShouldCreateTableFromTargetType()
+        public async Task ShouldCreateTableFromTargetType()
         {
             var reflectionWrapper = new ReflectionWrapper();
             var activatorWrapper = new ActivatorWrapper();
@@ -56,12 +57,12 @@ public void ShouldCreateTableFromTargetType()
             table.AddRow(new List<string> { "foorow1", "barrow1" });
             table.AddRow(new List<string> { "foorow2", "barrow2" });
 
-            var executionResult = orchestrator.ExecuteStep(gaugeMethod, SerializeTable(table));
+            var executionResult = await orchestrator.ExecuteStep(gaugeMethod, SerializeTable(table));
             ClassicAssert.False(executionResult.Failed);
         }
 
         [Test]
-        public void ShouldExecuteMethodAndReturnResult()
+        public async Task ShouldExecuteMethodAndReturnResult()
         {
             var reflectionWrapper = new ReflectionWrapper();
             var activatorWrapper = new ActivatorWrapper();
@@ -76,13 +77,12 @@ public void ShouldExecuteMethodAndReturnResult()
             var gaugeMethod = assemblyLoader.GetStepRegistry()
                 .MethodFor("A context step which gets executed before every scenario");
 
-            var executionResult = orchestrator.ExecuteStep(gaugeMethod);
+            var executionResult = await orchestrator.ExecuteStep(gaugeMethod);
             ClassicAssert.False(executionResult.Failed);
         }
 
-
         [Test]
-        public void ShouldGetPendingMessages()
+        public async Task ShouldGetPendingMessages()
         {
             var reflectionWrapper = new ReflectionWrapper();
             var activatorWrapper = new ActivatorWrapper();
@@ -97,14 +97,36 @@ public void ShouldGetPendingMessages()
 
             var gaugeMethod = assemblyLoader.GetStepRegistry().MethodFor("Say {} to {}");
 
-            var executionResult = executionOrchestrator.ExecuteStep(gaugeMethod, "hello", "world");
+            var executionResult = await executionOrchestrator.ExecuteStep(gaugeMethod, "hello", "world");
 
             ClassicAssert.False(executionResult.Failed);
             ClassicAssert.Contains("hello, world!", executionResult.Message);
         }
 
         [Test]
-        public void ShouldGetStacktraceForAggregateException()
+        public async Task ShouldExecuteAsyncStepImplementation()
+        {
+            var reflectionWrapper = new ReflectionWrapper();
+            var activatorWrapper = new ActivatorWrapper();
+            var path = new AssemblyLocater(new DirectoryWrapper()).GetTestAssembly();
+            var assemblyLoader = new AssemblyLoader(path, new GaugeLoadContext(path), reflectionWrapper, activatorWrapper, new StepRegistry());
+            var classInstanceManager = assemblyLoader.GetClassInstanceManager();
+            var executionInfoMapper = new ExecutionInfoMapper(assemblyLoader, activatorWrapper);
+            var executionOrchestrator = new ExecutionOrchestrator(reflectionWrapper, assemblyLoader,
+                classInstanceManager,
+                new HookExecutor(assemblyLoader, reflectionWrapper, classInstanceManager, executionInfoMapper),
+                new StepExecutor(assemblyLoader, reflectionWrapper, classInstanceManager));
+
+            var gaugeMethod = assemblyLoader.GetStepRegistry().MethodFor("Say {} to {} async");
+
+            var executionResult = await executionOrchestrator.ExecuteStep(gaugeMethod, "hello", "async world");
+
+            Assert.That(executionResult.Failed, Is.False, executionResult.ErrorMessage);
+            StringAssert.Contains("hello, async world!", executionResult.Message.ToString());
+        }
+
+        [Test]
+        public async Task ShouldGetStacktraceForAggregateException()
         {
             var reflectionWrapper = new ReflectionWrapper();
             var activatorWrapper = new ActivatorWrapper();
@@ -118,7 +140,7 @@ public void ShouldGetStacktraceForAggregateException()
                 new StepExecutor(assemblyLoader, reflectionWrapper, classInstanceManager));
 
             var gaugeMethod = assemblyLoader.GetStepRegistry().MethodFor("I throw an AggregateException");
-            var executionResult = executionOrchestrator.ExecuteStep(gaugeMethod);
+            var executionResult = await executionOrchestrator.ExecuteStep(gaugeMethod);
 
             ClassicAssert.True(executionResult.Failed);
             ClassicAssert.True(executionResult.StackTrace.Contains("First Exception"));
@@ -141,7 +163,7 @@ public void ShouldGetStepTextsForMethod()
         }
 
         [Test]
-        public void SuccessIsFalseOnSerializableExceptionThrown()
+        public async Task SuccessIsFalseOnSerializableExceptionThrown()
         {
             const string expectedMessage = "I am a custom serializable exception";
             var reflectionWrapper = new ReflectionWrapper();
@@ -156,7 +178,7 @@ public void SuccessIsFalseOnSerializableExceptionThrown()
                 new StepExecutor(assemblyLoader, reflectionWrapper, classInstanceManager));
             var gaugeMethod = assemblyLoader.GetStepRegistry().MethodFor("I throw a serializable exception");
 
-            var executionResult = executionOrchestrator.ExecuteStep(gaugeMethod);
+            var executionResult = await executionOrchestrator.ExecuteStep(gaugeMethod);
 
             ClassicAssert.True(executionResult.Failed);
             ClassicAssert.AreEqual(expectedMessage, executionResult.ErrorMessage);
@@ -165,7 +187,7 @@ public void SuccessIsFalseOnSerializableExceptionThrown()
         }
 
         [Test]
-        public void SuccessIsFalseOnUnserializableExceptionThrown()
+        public async Task SuccessIsFalseOnUnserializableExceptionThrown()
         {
             const string expectedMessage = "I am a custom exception";
             var reflectionWrapper = new ReflectionWrapper();
@@ -180,7 +202,7 @@ public void SuccessIsFalseOnUnserializableExceptionThrown()
                 new StepExecutor(assemblyLoader, reflectionWrapper, classInstanceManager));
 
             var gaugeMethod = assemblyLoader.GetStepRegistry().MethodFor("I throw an unserializable exception");
-            var executionResult = executionOrchestrator.ExecuteStep(gaugeMethod);
+            var executionResult = await executionOrchestrator.ExecuteStep(gaugeMethod);
             ClassicAssert.True(executionResult.Failed);
             ClassicAssert.AreEqual(expectedMessage, executionResult.ErrorMessage);
             StringAssert.Contains("IntegrationTestSample.StepImplementation.ThrowUnserializableException",

diff --git a/integration-test/ExternalReferenceTests.cs b/integration-test/ExternalReferenceTests.cs
@@ -7,6 +7,7 @@
 
 using System;
 using System.Threading;
+using System.Threading.Tasks;
 using Gauge.Dotnet.Models;
 using Gauge.Dotnet.Processors;
 using Gauge.Dotnet.Wrappers;
@@ -43,7 +44,7 @@ public void ShouldGetStepsFromReference(string referenceType, string stepText, s
         [Test]
         [TestCase("ProjectReference", "Take Screenshot in reference Project", "ReferenceProject-IDoNotExist.png")]
         [TestCase("DllReference", "Take Screenshot in reference DLL", "ReferenceDll-IDoNotExist.png")]
-        public void ShouldRegisterScreenshotWriterFromReference(string referenceType, string stepText, string expected)
+        public async Task ShouldRegisterScreenshotWriterFromReference(string referenceType, string stepText, string expected)
         {
             Environment.SetEnvironmentVariable("GAUGE_PROJECT_ROOT", TestUtils.GetIntegrationTestSampleDirectory(referenceType));
             var reflectionWrapper = new ReflectionWrapper();
@@ -66,7 +67,7 @@ public void ShouldRegisterScreenshotWriterFromReference(string referenceType, st
                 ActualStepText = stepText
             };
 
-            var result = executeStepProcessor.Process(message);
+            var result = await executeStepProcessor.Process(message);
             var protoExecutionResult = result.ExecutionResult;
 
             ClassicAssert.IsNotNull(protoExecutionResult);

diff --git a/integration-test/ImplementCodeProcessorTests.cs b/integration-test/ImplementCodeProcessorTests.cs
@@ -77,7 +77,7 @@ public void ShouldProcessMessageForExistingClass()
             var result = processor.Process(message);
             ClassicAssert.AreEqual(1, result.TextDiffs.Count);
             StringAssert.Contains("Step Method", result.TextDiffs[0].Content);
-            ClassicAssert.AreEqual(107, result.TextDiffs[0].Span.Start);
+            ClassicAssert.AreEqual(115, result.TextDiffs[0].Span.Start);
         }
 
         [Test]