Add support for query parameters, asynchronous response and non-Windows machines (#15)

metro-gn0me · Shreyansh Kulshreshtha · web-flow · commit b50a44351017 · 2023-05-29T11:23:11.000+01:00
Co-authored-by: Shreyansh Kulshreshtha &lt;shreyansh.kulshreshtha@publicissapient.com&gt;
diff --git a/LogicAppUnit/Hosting/CallbackUrlDefinition.cs b/LogicAppUnit/Hosting/CallbackUrlDefinition.cs
@@ -64,12 +64,20 @@ public string QueryString
         /// <summary>
         /// Gets the value, with a relative path component.
         /// </summary>
+        /// <param name="queryParams">The query parameters to be passed to the workflow.</param>
         /// <param name="relativePath">The relative path to be used in the trigger. The path must already be URL-encoded.</param>
-        public Uri ValueWithRelativePath(string relativePath)
+        public Uri ValueWithQueryAndRelativePath(Dictionary<string, string> queryParams, string relativePath)
         {
-            // If there is no relative path, use the 'Value'
-            if (string.IsNullOrEmpty(relativePath))
-                return Value;
+            // If there is a relative path, remove the preceding "/"
+            // Relative path should not have a preceding "/";
+            // See Remark under https://learn.microsoft.com/en-us/dotnet/api/system.uri.-ctor?view=net-7.0#system-uri-ctor(system-uri-system-string)
+            if (!string.IsNullOrEmpty(relativePath))
+                relativePath = relativePath.TrimStart('/');
+
+            // If there are query parameters, add them to the Queries property
+            if (queryParams is not null)
+                foreach (var pair in queryParams)
+                    Queries.Add(pair.Key, pair.Value);
 
             // Make sure the base path has a trailing slash to preserve the relative path in 'Value'
             string basePathAsString = BasePath.ToString();
diff --git a/LogicAppUnit/Hosting/TestEnvironment.cs b/LogicAppUnit/Hosting/TestEnvironment.cs
@@ -39,17 +39,22 @@ internal class TestEnvironment
         /// <summary>
         /// The management host name.
         /// </summary>
-        public static readonly string ManagementHostName = $"{Environment.MachineName}";
+        public static readonly string MachineHostName = OperatingSystem.IsWindows() ? Environment.MachineName : "localhost";
+
+        /// <summary>
+        /// The management host name.
+        /// </summary>
+        public static readonly string ManagementHostName = OperatingSystem.IsWindows() ? Environment.MachineName : "localhost";
 
         /// <summary>
         /// The test host uri.
         /// </summary>
-        public static readonly string FlowV2TestHostUri = (new UriBuilder(Uri.UriSchemeHttp, Environment.MachineName, 7071).Uri.ToString()).TrimEnd('/');
+        public static readonly string FlowV2TestHostUri = (new UriBuilder(Uri.UriSchemeHttp, MachineHostName, 7071).Uri.ToString()).TrimEnd('/');
 
         /// <summary>
         /// The mock test host uri.
         /// </summary>
-        public static readonly string FlowV2MockTestHostUri = (new UriBuilder(Uri.UriSchemeHttp, Environment.MachineName, 7075).Uri.ToString()).TrimEnd('/');
+        public static readonly string FlowV2MockTestHostUri = (new UriBuilder(Uri.UriSchemeHttp, MachineHostName, 7075).Uri.ToString()).TrimEnd('/');
 
         /// <summary>
         /// The test host uri.
diff --git a/LogicAppUnit/Hosting/WorkflowTestHost.cs b/LogicAppUnit/Hosting/WorkflowTestHost.cs
@@ -208,15 +208,23 @@ private static void KillFunctionHostProcesses()
         }
 
         /// <summary>
-        /// Retrieve the exact path of func.exe (Azure Function core tools). 
+        /// Retrieve the exact path of func executable (Azure Function core tools). 
         /// </summary>
-        /// <returns>The path to func.exe.</returns>
-        /// <exception cref="Exception">Thrown when the location of func.exe could not be found.</exception>
+        /// <returns>The path to the func executable.</returns>
+        /// <exception cref="Exception">Thrown when the location of func executable could not be found.</exception>
         private static string GetEnvPathForFunctionTools()
         {
-            var enviromentPath = Environment.GetEnvironmentVariable("PATH", EnvironmentVariableTarget.Machine);
-
-            var exePath = enviromentPath.Split(';').Select(x => Path.Combine(x, "func.exe")).Where(x => File.Exists(x)).FirstOrDefault();
+            string exePath;
+            if(OperatingSystem.IsWindows())
+            {
+                var enviromentPath = Environment.GetEnvironmentVariable("PATH", EnvironmentVariableTarget.Machine);
+                exePath = enviromentPath.Split(';').Select(x => Path.Combine(x, "func.exe")).Where(x => File.Exists(x)).FirstOrDefault();
+            }
+            else
+            {
+                var enviromentPath = Environment.GetEnvironmentVariable("PATH");
+                exePath = enviromentPath.Split(':').Select(x => Path.Combine(x, "func")).Where(x => File.Exists(x)).FirstOrDefault();
+            }
 
             if (!string.IsNullOrWhiteSpace(exePath))
             {
@@ -225,7 +233,7 @@ private static string GetEnvPathForFunctionTools()
             }
             else
             {
-                throw new Exception("Enviroment variables do not have FUNC.EXE path added.");
+                throw new Exception("Enviroment variables do not have func executable path added.");
             }
         }
 
diff --git a/LogicAppUnit/ITestRunner.cs b/LogicAppUnit/ITestRunner.cs
@@ -151,6 +151,28 @@ public interface ITestRunner : IDisposable
         /// </remarks>
         HttpResponseMessage TriggerWorkflow(HttpMethod method, Dictionary<string, string> requestHeaders = null);
 
+        /// <summary>
+        /// Trigger a workflow using query parameters, an empty request content and optional request headers.
+        /// </summary>
+        /// <param name="queryParams">The query parameters to be passed to the workflow.</param>
+        /// <param name="method">The HTTP method, this needs to match the method defined in the HTTP trigger in the workflow.</param>
+        /// <param name="requestHeaders">The request headers.</param>
+        /// <returns>The response from the workflow.</returns>
+        /// <remarks>
+        /// An empty request body may be used for workflows that contain triggers that do not use a request body, for example a Recurrence trigger.
+        /// </remarks>
+        HttpResponseMessage TriggerWorkflow(Dictionary<string, string> queryParams, HttpMethod method, Dictionary<string, string> requestHeaders = null);
+
+        /// <summary>
+        /// Trigger a workflow using query parameters, a relative path and optional request headers.
+        /// </summary>
+        /// <param name="queryParams">The query parameters to be passed to the workflow.</param>
+        /// <param name="method">The HTTP method, this needs to match the method defined in the HTTP trigger in the workflow.</param>
+        /// <param name="relativePath">The relative path to be used in the trigger. The path must already be URL-encoded.</param>
+        /// <param name="requestHeaders">The request headers.</param>
+        /// <returns>The response from the workflow.</returns>
+        HttpResponseMessage TriggerWorkflow(Dictionary<string, string> queryParams, HttpMethod method, string relativePath, Dictionary<string, string> requestHeaders = null);
+
         /// <summary>
         /// Trigger a workflow using a request body and optional request headers.
         /// </summary>
@@ -170,6 +192,17 @@ public interface ITestRunner : IDisposable
         /// <returns>The response from the workflow.</returns>
         HttpResponseMessage TriggerWorkflow(HttpContent content, HttpMethod method, string relativePath, Dictionary<string, string> requestHeaders = null);
 
+        /// <summary>
+        /// Trigger a workflow using query parameters, a request body, a relative path and optional request headers.
+        /// </summary>
+        /// <param name="queryParams">The query parameters to be passed to the workflow.</param>
+        /// <param name="content">The content (including any content headers) for running the workflow, or <c>null</c> if there is no content.</param>
+        /// <param name="method">The HTTP method, this needs to match the method defined in the HTTP trigger in the workflow.</param>
+        /// <param name="relativePath">The relative path to be used in the trigger. The path must already be URL-encoded.</param>
+        /// <param name="requestHeaders">The request headers.</param>
+        /// <returns>The response from the workflow.</returns>
+        HttpResponseMessage TriggerWorkflow(Dictionary<string, string> queryParams, HttpContent content, HttpMethod method, string relativePath, Dictionary<string, string> requestHeaders = null);
+
         #endregion // TriggerWorkflow
 
         /// <summary>
@@ -178,5 +211,11 @@ public interface ITestRunner : IDisposable
         /// <param name="assertion">The test assertion to be run.</param>
         /// <exception cref="AssertFailedException">Thrown when the test assertion fails.</exception>
         void ExceptionWrapper(Action assertion);
+
+        /// <summary>
+        /// Configure the runner to wait for and return the asynchronous response.
+        /// </summary>
+        /// <param name="maxTimeout">The maximum time to poll for the asynchronous response after which runner should time out.</param>
+        void WaitForAsynchronousResponse(TimeSpan maxTimeout);
     }
 }
diff --git a/LogicAppUnit/InternalHelper/WorkflowApiHelper.cs b/LogicAppUnit/InternalHelper/WorkflowApiHelper.cs
@@ -110,6 +110,11 @@ public CallbackUrlDefinition GetWorkflowCallbackDefinition(string triggerName)
             // Documentation: https://learn.microsoft.com/en-us/rest/api/logic/workflow-triggers/list-callback-url
             try
             {
+                // On a mac device, without some delay, the test fails 
+                // with a "System.Net.Http.HttpRequestException: Connection refused" exception
+                if (!OperatingSystem.IsWindows())
+                    System.Threading.Thread.Sleep(500);
+
                 using (var workflowTriggerCallbackResponse = _client.PostAsync(
                     TestEnvironment.GetTriggerCallbackRequestUri(flowName: _workflowName, triggerName: triggerName),
                     ContentHelper.CreatePlainStringContent("")).Result)
diff --git a/LogicAppUnit/TestRunner.cs b/LogicAppUnit/TestRunner.cs
@@ -31,6 +31,11 @@ public class TestRunner : ITestRunner, IDisposable
         private string _runId;
         private string _clientTrackingId;
 
+        // Whether to wait for the asynchronous response by polling the redirected URI
+        private bool _waitForAsyncResponse;
+        // Maximum time to wait for the asynchronous response before timing out 
+        private TimeSpan _asyncResponseTimeout;
+
         // Requests sent to the mock test server that are generated by the workflow during its execution.
         // Use a ConcurrentBag to store the requests during the test execution to ensure thread safety of this collection
         private ConcurrentBag<MockRequest> _mockRequests;
@@ -99,6 +104,13 @@ public WorkflowRunStatus WorkflowRunStatus
 
         #region Lifetime management
 
+        /// <inheritdoc cref="ITestRunner.WaitForAsynchronousResponse(TimeSpan)"/>
+        public void WaitForAsynchronousResponse(TimeSpan maxTimeout)
+        {
+            _waitForAsyncResponse = true;
+            _asyncResponseTimeout = maxTimeout;
+        }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="TestRunner"/> class.
         /// </summary>
@@ -282,17 +294,35 @@ public Dictionary<string, string> GetWorkflowActionTrackedProperties(string acti
         /// <inheritdoc cref="ITestRunner.TriggerWorkflow(HttpMethod, Dictionary{string, string})" />
         public HttpResponseMessage TriggerWorkflow(HttpMethod method, Dictionary<string, string> requestHeaders = null)
         {
-            return TriggerWorkflow(null, method, requestHeaders);
+            return TriggerWorkflow(null, null, method, string.Empty, requestHeaders);
+        }
+
+        /// <inheritdoc cref="ITestRunner.TriggerWorkflow(Dictionary{string, string}, HttpMethod, Dictionary{string, string})" />
+        public HttpResponseMessage TriggerWorkflow(Dictionary<string, string> queryParams, HttpMethod method, Dictionary<string, string> requestHeaders = null)
+        {
+            return TriggerWorkflow(queryParams, null, method, string.Empty, requestHeaders);
+        }
+
+        /// <inheritdoc cref="ITestRunner.TriggerWorkflow(Dictionary{string, string}, HttpMethod, string, Dictionary{string, string})" />
+        public HttpResponseMessage TriggerWorkflow(Dictionary<string, string> queryParams, HttpMethod method, string relativePath, Dictionary<string, string> requestHeaders = null)
+        {
+            return TriggerWorkflow(queryParams, null, method, relativePath, requestHeaders);
         }
 
         /// <inheritdoc cref="ITestRunner.TriggerWorkflow(HttpContent, HttpMethod, Dictionary{string, string})" />
         public HttpResponseMessage TriggerWorkflow(HttpContent content, HttpMethod method, Dictionary<string, string> requestHeaders = null)
         {
-            return TriggerWorkflow(content, method, string.Empty, requestHeaders);
+            return TriggerWorkflow(null, content, method, string.Empty, requestHeaders);
         }
 
         /// <inheritdoc cref="ITestRunner.TriggerWorkflow(HttpContent, HttpMethod, string, Dictionary{string, string})" />
         public HttpResponseMessage TriggerWorkflow(HttpContent content, HttpMethod method, string relativePath, Dictionary<string, string> requestHeaders = null)
+        {
+            return TriggerWorkflow(null, content, method, relativePath, requestHeaders);
+        }
+
+        /// <inheritdoc cref="ITestRunner.TriggerWorkflow(Dictionary{string, string}, HttpContent, HttpMethod, string, Dictionary{string, string})" />
+        public HttpResponseMessage TriggerWorkflow(Dictionary<string, string> queryParams, HttpContent content, HttpMethod method, string relativePath, Dictionary<string, string> requestHeaders = null)
         {
             string triggerName = _workflowDefinition.HttpTriggerName;
             if (string.IsNullOrEmpty(triggerName))
@@ -306,7 +336,7 @@ public HttpResponseMessage TriggerWorkflow(HttpContent content, HttpMethod metho
             {
                 Content = content,
                 Method = method,
-                RequestUri = callbackDef.ValueWithRelativePath(relativePath)
+                RequestUri = callbackDef.ValueWithQueryAndRelativePath(queryParams, relativePath)
             };
 
             if (requestHeaders != null)
@@ -432,30 +462,73 @@ private JToken GetWorkflowActionRepetitionMessage(string actionName, int repetit
         /// <returns>The response from the workflow.</returns>
         private HttpResponseMessage PollAndReturnFinalWorkflowResponse(HttpRequestMessage httpRequestMessage)
         {
+            HttpResponseMessage asyncResponse = null;
+
             // Call the endpoint for the HTTP trigger
             var initialWorkflowHttpResponse = _client.SendAsync(httpRequestMessage).Result;
 
             // Store some of the run metadata for test assertions, this may not exist for stateless workflows
             _runId = GetHeader(initialWorkflowHttpResponse.Headers, "x-ms-workflow-run-id");
             _clientTrackingId = GetHeader(initialWorkflowHttpResponse.Headers, "x-ms-client-tracking-id");
 
-            if (initialWorkflowHttpResponse.StatusCode != HttpStatusCode.Accepted)
+            // Check for and handle asynchronous response
+            var callbackLocation = initialWorkflowHttpResponse.Headers?.Location;
+            if (initialWorkflowHttpResponse.StatusCode == HttpStatusCode.Accepted && callbackLocation is not null)
             {
-                return initialWorkflowHttpResponse;
+                // If the _waitForAsyncResponse is not set (to true), return the initial response
+                if (!_waitForAsyncResponse)
+                {
+                    return initialWorkflowHttpResponse;
+                }
+
+                var retryAfterSeconds = initialWorkflowHttpResponse.Headers?.RetryAfter?.Delta ?? TimeSpan.FromSeconds(5);
+
+                var stopwatchAsyncRes = new Stopwatch();
+                stopwatchAsyncRes.Start();
+
+                while (stopwatchAsyncRes.Elapsed < _asyncResponseTimeout)
+                {
+                    using (var latestAsyncResponse = _client.GetAsync(callbackLocation).Result)
+                    {
+                        if (latestAsyncResponse.StatusCode != HttpStatusCode.Accepted)
+                        {
+                            stopwatchAsyncRes.Stop();
+                            asyncResponse = latestAsyncResponse;
+                            break;
+                        }
+                        Thread.Sleep(retryAfterSeconds);
+                    }
+                }
+
+                if (stopwatchAsyncRes.Elapsed >= _asyncResponseTimeout)
+                {
+                    throw new TestException($"Workflow is taking more than {_asyncResponseTimeout.TotalMinutes} minutes for returning the final async response.");
+                }
             }
 
+            // Wait till the workflow ends, i.e., workflow status is not "Running".
+            // This should be checked in case of HTTP trigger workflows as well to make sure that any
+            // actions after the Response action are properly run before testing their outputs.
             var stopwatch = new Stopwatch();
             stopwatch.Start();
-
             while (stopwatch.Elapsed < TimeSpan.FromMinutes(Constants.MAX_TIME_MINUTES_WHILE_POLLING_WORKFLOW_RESULT))
             {
                 using (var latestWorkflowHttpResponse = _client.GetAsync(TestEnvironment.GetRunsRequestUriWithManagementHost(flowName: _workflowDefinition.WorkflowName)).Result)
                 {
                     var latestWorkflowHttpResponseContent = latestWorkflowHttpResponse.Content.ReadAsAsync<JToken>().Result;
                     var runStatusOfWorkflow = latestWorkflowHttpResponseContent["value"][0]["properties"]["status"].ToString();
-                    // If we got status code other than Accepted then return the response
+                    // If we got status code other than Accepted then return the appropriate response.
                     if (latestWorkflowHttpResponse.StatusCode != HttpStatusCode.Accepted && runStatusOfWorkflow != ActionStatus.Running.ToString())
                     {
+                        // If there is an asynchronous response return it.
+                        if (asyncResponse is not null)
+                            return asyncResponse;
+
+                        // If the initial response was from an HTTP trigger workflow, return it.
+                        if (initialWorkflowHttpResponse.StatusCode != HttpStatusCode.Accepted)
+                            return initialWorkflowHttpResponse;
+
+                        // It must be a non-HTTP trigger workflow, return the output of the workflow run.
                         return latestWorkflowHttpResponse;
                     }
                     Thread.Sleep(1000);

Original file line number	Diff line number	Diff line change
`@@ -208,15 +208,23 @@ private static void KillFunctionHostProcesses()`
`208`	`208`	`}`
`209`	`209`
`210`	`210`	`/// <summary>`
`211`		`- /// Retrieve the exact path of func.exe (Azure Function core tools).`
	`211`	`+ /// Retrieve the exact path of func executable (Azure Function core tools).`
`212`	`212`	`/// </summary>`
`213`		`- /// <returns>The path to func.exe.</returns>`
`214`		`- /// <exception cref="Exception">Thrown when the location of func.exe could not be found.</exception>`
	`213`	`+ /// <returns>The path to the func executable.</returns>`
	`214`	`+ /// <exception cref="Exception">Thrown when the location of func executable could not be found.</exception>`
`215`	`215`	`private static string GetEnvPathForFunctionTools()`
`216`	`216`	`{`
`217`		`- var enviromentPath = Environment.GetEnvironmentVariable("PATH", EnvironmentVariableTarget.Machine);`
`218`		`-`
`219`		`- var exePath = enviromentPath.Split(';').Select(x => Path.Combine(x, "func.exe")).Where(x => File.Exists(x)).FirstOrDefault();`
	`217`	`+ string exePath;`
	`218`	`+ if(OperatingSystem.IsWindows())`
	`219`	`+ {`
	`220`	`+ var enviromentPath = Environment.GetEnvironmentVariable("PATH", EnvironmentVariableTarget.Machine);`
	`221`	`+ exePath = enviromentPath.Split(';').Select(x => Path.Combine(x, "func.exe")).Where(x => File.Exists(x)).FirstOrDefault();`
	`222`	`+ }`
	`223`	`+ else`
	`224`	`+ {`
	`225`	`+ var enviromentPath = Environment.GetEnvironmentVariable("PATH");`
	`226`	`+ exePath = enviromentPath.Split(':').Select(x => Path.Combine(x, "func")).Where(x => File.Exists(x)).FirstOrDefault();`
	`227`	`+ }`
`220`	`228`
`221`	`229`	`if (!string.IsNullOrWhiteSpace(exePath))`
`222`	`230`	`{`
`@@ -225,7 +233,7 @@ private static string GetEnvPathForFunctionTools()`
`225`	`233`	`}`
`226`	`234`	`else`
`227`	`235`	`{`
`228`		`- throw new Exception("Enviroment variables do not have FUNC.EXE path added.");`
	`236`	`+ throw new Exception("Enviroment variables do not have func executable path added.");`
`229`	`237`	`}`
`230`	`238`	`}`
`231`	`239`