[Durable Functions] Add E2E test (#372)

Author: AnatoliB

azure-pipelines-1.yml

@@ -29,6 +29,7 @@ steps:
     AzureWebJobsServiceBus: $(AzureWebJobsServiceBus)
     AzureWebJobsEventHubSender: $(AzureWebJobsEventHubSender)
     FUNCTIONS_WORKER_RUNTIME : "powershell"
+    PSWorkerEnableExperimentalDurableFunctions: "true"
   continueOnError: true
   displayName: 'Running E2ETest'
 

azure-pipelines-2.yml

@@ -24,6 +24,7 @@ steps:
     AzureWebJobsEventHubSender: $(AzureWebJobsEventHubSender)
     FUNCTIONS_WORKER_RUNTIME : "powershell"
     FunctionAppUrl: $(FunctionAppUrl)
+    PSWorkerEnableExperimentalDurableFunctions: "true"
   continueOnError: true
   displayName: 'Running E2ETest'
 

azure-pipelines.yml

@@ -32,6 +32,7 @@ steps:
     AzureWebJobsServiceBus: $(AzureWebJobsServiceBus)
     AzureWebJobsEventHubSender: $(AzureWebJobsEventHubSender)    
     FUNCTIONS_WORKER_RUNTIME : "powershell"
+    PSWorkerEnableExperimentalDurableFunctions: "true"
   displayName: 'Running E2ETest'
 
 - task: CopyFiles@2

test/E2E/Azure.Functions.PowerShellWorker.E2E/Azure.Functions.PowerShellWorker.E2E/DurableEndToEndTests.cs

@@ -0,0 +1,94 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+namespace Azure.Functions.PowerShell.Tests.E2E
+{
+    using System;
+    using System.Net;
+    using System.Threading.Tasks;
+    using Xunit;
+
+    using System.Net.Http;
+    using Newtonsoft.Json;
+
+    [Collection(Constants.FunctionAppCollectionName)]
+    public class DurableEndToEndTests
+    {
+        private readonly FunctionAppFixture _fixture;
+
+        public DurableEndToEndTests(FunctionAppFixture fixture)
+        {
+            this._fixture = fixture;
+        }
+
+        [Fact]
+        public async Task DurableClientFollowsAsyncPattern()
+        {
+            var initialResponse = await Utilities.GetHttpTriggerResponse("DurableClient", queryString: string.Empty);
+            Assert.Equal(HttpStatusCode.Accepted, initialResponse.StatusCode);
+
+            var location = initialResponse.Headers.Location;
+            Assert.NotNull(location);
+
+            var initialResponseBody = await initialResponse.Content.ReadAsStringAsync();
+            dynamic initialResponseBodyObject = JsonConvert.DeserializeObject(initialResponseBody);
+            Assert.NotNull(initialResponseBodyObject.id);
+            var statusQueryGetUri = (string)initialResponseBodyObject.statusQueryGetUri;
+            Assert.Equal(location.ToString(), statusQueryGetUri);
+            Assert.NotNull(initialResponseBodyObject.sendEventPostUri);
+            Assert.NotNull(initialResponseBodyObject.purgeHistoryDeleteUri);
+            Assert.NotNull(initialResponseBodyObject.terminatePostUri);
+            Assert.NotNull(initialResponseBodyObject.rewindPostUri);
+
+            var orchestrationCompletionTimeout = TimeSpan.FromSeconds(60);
+            var startTime = DateTime.UtcNow;
+
+            using (var httpClient = new HttpClient())
+            {
+                while (true)
+                {
+                    var statusResponse = await httpClient.GetAsync(statusQueryGetUri);
+                    switch (statusResponse.StatusCode)
+                    {
+                        case HttpStatusCode.Accepted:
+                        {
+                            var statusResponseBody = await GetResponseBodyAsync(statusResponse);
+                            var runtimeStatus = (string)statusResponseBody.runtimeStatus;
+                            Assert.True(
+                                runtimeStatus == "Running" || runtimeStatus == "Pending",
+                                $"Unexpected runtime status: {runtimeStatus}");
+
+                            if (DateTime.UtcNow > startTime + orchestrationCompletionTimeout)
+                            {
+                                Assert.True(false, $"The orchestration has not completed after {orchestrationCompletionTimeout}");
+                            }
+
+                            await Task.Delay(TimeSpan.FromSeconds(2));
+                            break;
+                        }
+
+                        case HttpStatusCode.OK:
+                        {
+                            var statusResponseBody = await GetResponseBodyAsync(statusResponse);
+                            Assert.Equal("Completed", (string)statusResponseBody.runtimeStatus);
+                            Assert.Equal("Hello Tokyo", statusResponseBody.output[0].ToString());
+                            Assert.Equal("Hello Seattle", statusResponseBody.output[1].ToString());
+                            Assert.Equal("Hello London", statusResponseBody.output[2].ToString());
+                            return;
+                        }
+
+                        default:
+                            Assert.True(false, $"Unexpected orchestration status code: {statusResponse.StatusCode}");
+                            break;
+                    }
+                }
+            }
+        }
+
+        private static async Task<dynamic> GetResponseBodyAsync(HttpResponseMessage response)
+        {
+            var responseBody = await response.Content.ReadAsStringAsync();
+            return JsonConvert.DeserializeObject(responseBody);
+        }
+    }
+}

test/E2E/Azure.Functions.PowerShellWorker.E2E/Azure.Functions.PowerShellWorker.E2E/Utilities.cs

@@ -59,7 +59,7 @@ public static async Task<string> InvokeHttpTrigger(string functionName, string q
             return await response.Content.ReadAsStringAsync();
         }
 
-        private static async Task<HttpResponseMessage> GetHttpTriggerResponse(string functionName, string queryString)
+        public static async Task<HttpResponseMessage> GetHttpTriggerResponse(string functionName, string queryString)
         {
             string uri = $"api/{functionName}{queryString}";
             HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, uri);

test/E2E/TestFunctionApp/DurableActivity/function.json

@@ -0,0 +1,9 @@
+{
+  "bindings": [
+    {
+      "name": "name",
+      "type": "activityTrigger",
+      "direction": "in"
+    }
+  ]
+}

test/E2E/TestFunctionApp/DurableActivity/run.ps1

@@ -0,0 +1,6 @@
+param($name)
+
+Write-Host "DurableActivity($name) started"
+Start-Sleep -Seconds 5
+Write-Host "DurableActivity($name) finished"
+return "Hello $name"

test/E2E/TestFunctionApp/DurableClient/function.json

@@ -0,0 +1,24 @@
+{
+  "bindings": [
+    {
+      "authLevel": "anonymous",
+      "type": "httpTrigger",
+      "direction": "in",
+      "name": "Request",
+      "methods": [
+        "get",
+        "post"
+      ]
+    },
+    {
+      "type": "http",
+      "direction": "out",
+      "name": "Response"
+    },
+    {
+      "name": "starter",
+      "type": "orchestrationClient",
+      "direction": "in"
+    }    
+  ]
+}

test/E2E/TestFunctionApp/DurableClient/run.ps1

@@ -0,0 +1,15 @@
+using namespace System.Net
+
+param($Request, $TriggerMetadata)
+
+Write-Host "DurableClient started"
+
+$ErrorActionPreference = 'Stop'
+
+$InstanceId = Start-NewOrchestration -FunctionName 'DurableOrchestrator' -InputObject 'Hello'
+Write-Host "Started orchestration with ID = '$InstanceId'"
+
+$Response = New-OrchestrationCheckStatusResponse -Request $Request -InstanceId $InstanceId
+Push-OutputBinding -Name Response -Value $Response
+
+Write-Host "DurableClient completed"

test/E2E/TestFunctionApp/DurableOrchestrator/function.json

@@ -0,0 +1,9 @@
+{
+  "bindings": [
+    {
+      "name": "Context",
+      "type": "orchestrationTrigger",
+      "direction": "in"
+    }
+  ]
+}