Skip writing functions.metadata when using source gen (#2974)

jviau · web-flow · commit 4e9f1379e398 · 2025-06-23T10:08:14.000-07:00
* Skip writing functions.metadata when using source gen

* Update SDK tests

* update release notes

* Fix tests, allow for manual override of writing functions.metadata

* Update tests for force write metadata

* Fix copy condition, refactor tests

* FIx IDisposable

* Fix restore with rid

* Fix bad merge

* Restore separately for test
diff --git a/sdk/Sdk/Targets/Microsoft.Azure.Functions.Worker.Sdk.targets b/sdk/Sdk/Targets/Microsoft.Azure.Functions.Worker.Sdk.targets
@@ -48,7 +48,9 @@ WARNING:  DO NOT MODIFY this file unless you are knowledgeable about MSBuild and
     <FunctionsEnablePlaceholder Condition="'$(FunctionsEnablePlaceholder)' == ''">false</FunctionsEnablePlaceholder>
     <FunctionsEnableWorkerIndexing Condition="'$(FunctionsEnableWorkerIndexing)' == ''">true</FunctionsEnableWorkerIndexing>
     <FunctionsEnableMetadataSourceGen>$(FunctionsEnableWorkerIndexing)</FunctionsEnableMetadataSourceGen>
-    <FunctionsAutoRegisterGeneratedMetadataProvider>$(FunctionsEnableWorkerIndexing)</FunctionsAutoRegisterGeneratedMetadataProvider> 
+    <FunctionsAutoRegisterGeneratedMetadataProvider>$(FunctionsEnableWorkerIndexing)</FunctionsAutoRegisterGeneratedMetadataProvider>
+    <FunctionsWriteMetadataJson Condition="'$(FunctionsWriteMetadataJson)' == '' AND '$(FunctionsEnableMetadataSourceGen)' == 'true'">false</FunctionsWriteMetadataJson>
+    <FunctionsWriteMetadataJson Condition="'$(FunctionsWriteMetadataJson)' == ''">true</FunctionsWriteMetadataJson>
 
     <FunctionsEnableExecutorSourceGen Condition="'$(FunctionsEnableExecutorSourceGen)' == ''">true</FunctionsEnableExecutorSourceGen>
     <FunctionsAutoRegisterGeneratedFunctionsExecutor Condition="'$(FunctionsAutoRegisterGeneratedFunctionsExecutor)' == ''">true</FunctionsAutoRegisterGeneratedFunctionsExecutor>
@@ -184,9 +186,10 @@ WARNING:  DO NOT MODIFY this file unless you are knowledgeable about MSBuild and
       ReferencePaths="@(ReferencePath)"
       ExtensionsCsProjFilePath="$(ExtensionsCsProj)"
       AzureFunctionsVersion="$(AzureFunctionsVersion)"
+      WriteMetadataFile="$(FunctionsWriteMetadataJson)"
       TargetFrameworkIdentifier="$(TargetFrameworkIdentifier)"
       TargetFrameworkVersion="$(TargetFrameworkVersion)"
-      OutputPath="$(IntermediateOutputPath)"/>
+      OutputPath="$(IntermediateOutputPath)" />
   </Target>
 
   <!-- Generate worker.config.json. -->
@@ -240,7 +243,8 @@ WARNING:  DO NOT MODIFY this file unless you are knowledgeable about MSBuild and
 
     <!-- Hook all these files into CopyToOutputDirectory by appending to _NoneWithTargetPath. -->
     <ItemGroup>
-      <_FunctionsAdditionalFile Include="$(_FunctionsMetadataPath);$(_FunctionsWorkerConfigPath);$(_FunctionsIntermediateExtensionUpdatedJsonPath)" />
+      <_FunctionsAdditionalFile Include="$(_FunctionsMetadataPath)" Condition="'$(FunctionsWriteMetadataJson)' == 'true'" />
+      <_FunctionsAdditionalFile Include="$(_FunctionsWorkerConfigPath);$(_FunctionsIntermediateExtensionUpdatedJsonPath)" />
       <_FunctionsAdditionalFile Include="$(_FunctionsMetadataLoaderExtensionFile)" SubPath="$(_FunctionsExtensionsDirectory)/" />
       <_NoneWithTargetPath Include="@(_FunctionsAdditionalFile)"
         TargetPath="%(_FunctionsAdditionalFile.SubPath)%(Filename)%(Extension)"
diff --git a/sdk/Sdk/Tasks/GenerateFunctionMetadata.cs b/sdk/Sdk/Tasks/GenerateFunctionMetadata.cs
@@ -26,6 +26,8 @@ public class GenerateFunctionMetadata : Task
 
         public string? ExtensionsCsProjFilePath { get; set; }
 
+        public bool WriteMetadataFile { get; set; } = true;
+
         [Required]
         public ITaskItem[]? ReferencePaths { get; set; }
 
@@ -67,11 +69,18 @@ public override bool Execute()
 
         private void WriteMetadataWithRetry(IEnumerable<SdkFunctionMetadata> functions)
         {
+            if (!WriteMetadataFile)
+            {
+                Log.LogMessage("Skipping writing function metadata file.");
+                return;
+            }
+
             int attempt = 0;
             while (attempt < 10)
             {
                 try
                 {
+                    Log.LogMessage($"Writing function metadata to {OutputPath} directory.");
                     FunctionMetadataJsonWriter.WriteMetadata(functions, OutputPath!);
                     break;
                 }
diff --git a/sdk/release_notes.md b/sdk/release_notes.md
@@ -4,9 +4,9 @@
 - My change description (#PR/#issue)
 -->
 
-### Microsoft.Azure.Functions.Worker.Sdk 2.0.5
+### Microsoft.Azure.Functions.Worker.Sdk <version>
 
-- Address issue with design time build producing an error when project had not yet been built yet. (#3081)
+- Build no longer generates `functions.metadata` if source-generated metadata provider is enabled. (#2974)
 
 ### Microsoft.Azure.Functions.Worker.Sdk.Generators <version>
 
diff --git a/test/E2ETests/E2ETests/AspNetCore/CancellationEndToEndTests.cs b/test/E2ETests/E2ETests/AspNetCore/CancellationEndToEndTests.cs
@@ -37,10 +37,10 @@ public async Task HttpTriggerFunctions_WithCancellationToken_BehaveAsExpected(st
             await TestUtility.RetryAsync(() =>
             {
                 invocationStartLog = _fixture.TestLogs.CoreToolsLogs.Where(p => p.Contains($"Executing 'Functions.{functionName}'"));
-                return Task.FromResult(invocationStartLog.Count() >= 1);
+                return Task.FromResult(invocationStartLog.Any());
             });
 
-            // The task should be cancelled before it completes, mimicing a client closing the connection.
+            // The task should be cancelled before it completes, mimicking a client closing the connection.
             // This should lead to the worker getting an InvocationCancel request from the functions host
             cts.Cancel();
             await Assert.ThrowsAsync<TaskCanceledException>(async () => await task);
@@ -49,13 +49,13 @@ await TestUtility.RetryAsync(() =>
             await TestUtility.RetryAsync(() =>
             {
                 invocationEndLog = _fixture.TestLogs.CoreToolsLogs.Where(p => p.Contains($"Executed 'Functions.{functionName}'"));
-                return Task.FromResult(invocationEndLog.Count() >= 1);
+                return Task.FromResult(invocationEndLog.Any());
             });
 
             Assert.Contains(_fixture.TestLogs.CoreToolsLogs, log => log.Contains(expectedMessage, StringComparison.OrdinalIgnoreCase));
 
             // TODO: 2/3 of the test invocations will fail until the host with the ForwarderProxy fix is released - uncomment this line when the fix is released
-            Assert.NotEqual(null, invocationResult); // just here to 'use' invocationResult to avoid a warning.
+            Assert.NotNull(invocationResult); // just here to 'use' invocationResult to avoid a warning.
             // Assert.Contains(_fixture.TestLogs.CoreToolsLogs, log => log.Contains($"'Functions.{functionName}' ({invocationResult}", StringComparison.OrdinalIgnoreCase));
         }
 
diff --git a/test/E2ETests/E2ETests/Fixtures/FunctionAppFixture.cs b/test/E2ETests/E2ETests/Fixtures/FunctionAppFixture.cs
@@ -17,11 +17,11 @@ namespace Microsoft.Azure.Functions.Tests.E2ETests
 {
     public class FunctionAppFixture : IAsyncLifetime
     {
+        private readonly string _testApp = Constants.TestAppNames.E2EApp;
         private readonly ILogger _logger;
         private bool _disposed;
         private Process _funcProcess;
         private JobObjectRegistry _jobObjectRegistry;
-        private string _testApp = Constants.TestAppNames.E2EApp;
 
         public FunctionAppFixture(IMessageSink messageSink)
         {
@@ -32,7 +32,8 @@ public FunctionAppFixture(IMessageSink messageSink)
             _logger = loggerFactory.CreateLogger<FunctionAppFixture>();
         }
 
-        internal FunctionAppFixture(IMessageSink messageSink, string testApp) : this(messageSink)
+        internal FunctionAppFixture(IMessageSink messageSink, string testApp)
+            : this(messageSink)
         {
             _testApp = testApp;
         }
diff --git a/test/Sdk.E2ETests/InnerBuildTests.cs b/test/Sdk.E2ETests/InnerBuildTests.cs
@@ -1,6 +1,7 @@
 ﻿// Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the MIT License. See License.txt in the project root for license information.
 
+using System;
 using System.IO;
 using System.Threading.Tasks;
 using Newtonsoft.Json.Linq;
@@ -9,25 +10,27 @@
 
 namespace Microsoft.Azure.Functions.Sdk.E2ETests
 {
-    public class InnerBuildTests
+    public sealed class InnerBuildTests(ITestOutputHelper testOutputHelper) : IDisposable
     {
-        private readonly ITestOutputHelper _testOutputHelper;
+        private readonly ProjectBuilder _builder = new(
+            testOutputHelper,
+            Path.Combine(TestUtility.TestResourcesProjectsRoot, "FunctionApp01", "FunctionApp01.csproj"));
 
-        public InnerBuildTests(ITestOutputHelper testOutputHelper)
+        [Theory]
+        [InlineData("", false)]
+        [InlineData("-p:FunctionsEnableWorkerIndexing=true", false)]
+        [InlineData("-p:FunctionsEnableWorkerIndexing=true -p:FunctionsWriteMetadataJson=false", false)]
+        [InlineData("-p:FunctionsEnableWorkerIndexing=true -p:FunctionsWriteMetadataJson=true", true)]
+        [InlineData("-p:FunctionsEnableWorkerIndexing=false", true)]
+        [InlineData("-p:FunctionsEnableWorkerIndexing=false -p:FunctionsWriteMetadataJson=false", false)]
+        [InlineData("-p:FunctionsEnableWorkerIndexing=false -p:FunctionsWriteMetadataJson=true", true)]
+        public async Task Build_ScansReferences(string parameters, bool metadataGenerated)
         {
-            _testOutputHelper = testOutputHelper;
-        }
-
-        [Fact]
-        public async Task Build_ScansReferences()
-        {
-            string outputDir = await TestUtility.InitializeTestAsync(_testOutputHelper, nameof(Build_ScansReferences));
-            string projectFileDirectory = Path.Combine(TestUtility.TestResourcesProjectsRoot, "FunctionApp01", "FunctionApp01.csproj");
-
-            await TestUtility.RestoreAndBuildProjectAsync(projectFileDirectory, outputDir, null, _testOutputHelper);
+            await _builder.RestoreAsync();
+            await _builder.BuildAsync(parameters, restore: false);
 
             // Verify extensions.json contents
-            string extensionsJsonPath = Path.Combine(outputDir, "extensions.json");
+            string extensionsJsonPath = Path.Combine(_builder.OutputPath, "extensions.json");
             Assert.True(File.Exists(extensionsJsonPath));
 
             JToken extensionsJsonContents = JObject.Parse(File.ReadAllText(extensionsJsonPath));
@@ -54,8 +57,13 @@ public async Task Build_ScansReferences()
             Assert.True(JToken.DeepEquals(expectedExtensionsJson, extensionsJsonContents));
 
             // Verify functions.metadata contents
-            string functionsMetadataPath = Path.Combine(outputDir, "functions.metadata");
-            Assert.True(File.Exists(functionsMetadataPath));
+            string functionsMetadataPath = Path.Combine(_builder.OutputPath, "functions.metadata");
+            Assert.Equal(metadataGenerated, File.Exists(functionsMetadataPath));
+
+            if (!metadataGenerated)
+            {
+                return;
+            }
 
             JToken functionsMetadataContents = JArray.Parse(File.ReadAllText(functionsMetadataPath));
             JToken expectedFunctionsMetadata = JArray.Parse(@"[
@@ -115,5 +123,7 @@ public async Task Build_ScansReferences()
 
             Assert.True(JToken.DeepEquals(expectedFunctionsMetadata, functionsMetadataContents));
         }
+
+        public void Dispose() => _builder.Dispose();
     }
 }
diff --git a/test/Sdk.E2ETests/ProcessWrapper.cs b/test/Sdk.E2ETests/ProcessWrapper.cs
@@ -6,26 +6,27 @@
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
-using Xunit.Abstractions;
 
 namespace Microsoft.Azure.Functions.Sdk.E2ETests
 {
-    public class ProcessWrapper
+    public static class ProcessWrapper
     {
-
-        public async Task<int?> RunProcess(string fileName, string arguments, string workingDirectory, ITestOutputHelper testOutputHelper = null)
+        public static async Task<int?> RunProcessAsync(
+            string fileName, string arguments, string workingDirectory = null, Action<string> log = null)
         {
-            return await RunProcessInternal(fileName, arguments, workingDirectory, testOutputHelper);
+            return await RunProcessInternalAsync(fileName, arguments, workingDirectory, log);
         }
 
-        public async Task<Tuple<int?, string>> RunProcessForOutput(string fileName, string arguments, string workingDirectory, ITestOutputHelper testOutputHelper = null)
+        public static async Task<Tuple<int?, string>> RunProcessForOutputAsync(
+            string fileName, string arguments, string workingDirectory = null, Action<string> log = null)
         {
             StringBuilder processOutputStringBuilder = new StringBuilder();
-            var exitCode = await RunProcessInternal(fileName, arguments, workingDirectory, testOutputHelper, processOutputStringBuilder);
+            var exitCode = await RunProcessInternalAsync(fileName, arguments, workingDirectory, log, processOutputStringBuilder);
             return new Tuple<int?,string>(exitCode, processOutputStringBuilder.ToString());
         }
 
-        private async Task<int?> RunProcessInternal(string fileName, string arguments, string workingDirectory, ITestOutputHelper testOutputHelper = null, StringBuilder processOutputBuilder = null)
+        private static async Task<int?> RunProcessInternalAsync(
+            string fileName, string arguments, string workingDirectory = null, Action<string> log = null, StringBuilder processOutputBuilder = null)
         {
 
             SemaphoreSlim processExitSemaphore = new SemaphoreSlim(0, 1);
@@ -53,23 +54,17 @@ public class ProcessWrapper
             {
                 if (o.Data != null)
                 {
-                    testOutputHelper.WriteLine($"[{DateTime.UtcNow:O}] Error: {o.Data}");
-                    if (processOutputBuilder != null)
-                    {
-                        processOutputBuilder.AppendLine(o.Data);
-                    }
+                    log?.Invoke($"[{DateTime.UtcNow:O}] Error: {o.Data}");
+                    processOutputBuilder?.AppendLine(o.Data);
                 }
             };
 
             testProcess.OutputDataReceived += (s, o) =>
             {
                 if (o.Data != null)
                 {
-                    testOutputHelper.WriteLine($"[{DateTime.UtcNow:O}] {o.Data}");
-                    if (processOutputBuilder != null)
-                    {
-                        processOutputBuilder.AppendLine(o.Data);
-                    }
+                    log?.Invoke($"[{DateTime.UtcNow:O}] {o.Data}");
+                    processOutputBuilder?.AppendLine(o.Data);
                 }
             };
 
@@ -81,7 +76,7 @@ public class ProcessWrapper
             int wait = 3 * 60 * 1000;
             if (!await processExitSemaphore.WaitAsync(wait))
             {
-                testOutputHelper?.WriteLine($"Process '{testProcess.Id}' did not exit in {wait}ms.");
+               log?.Invoke($"Process '{testProcess.Id}' did not exit in {wait}ms.");
                 testProcess.Kill();
             }
 
diff --git a/test/Sdk.E2ETests/ProjectBuilder.cs b/test/Sdk.E2ETests/ProjectBuilder.cs
@@ -0,0 +1,106 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Microsoft.Azure.Functions.Sdk.E2ETests
+{
+    public sealed class ProjectBuilder(ITestOutputHelper logger, string project) : IDisposable
+    {
+#if DEBUG
+        public const string Configuration = "Debug";
+#elif RELEASE
+        public const string Configuration = "Release";
+#endif
+        public static readonly string LocalPackages = Path.Combine(TestUtility.PathToRepoRoot, "local");
+        public static readonly string SrcRoot = Path.Combine(TestUtility.PathToRepoRoot, "src");
+        public static readonly string SdkSolutionRoot = Path.Combine(TestUtility.PathToRepoRoot, "sdk");
+        public static readonly string SdkProjectRoot = Path.Combine(SdkSolutionRoot, "Sdk");
+        public static readonly string DotNetExecutable = "dotnet";
+        public static readonly string SdkVersion = "99.99.99-test";
+        public static readonly string SdkBuildProj = Path.Combine(TestUtility.PathToRepoRoot, "build", "Sdk.slnf");
+        public static readonly string NuGetOrgPackages = "https://api.nuget.org/v3/index.json";
+
+        private static Task _initialization;
+        private static object _sync;
+
+        private readonly TempDirectory _tempDirectory = new();
+
+        public string OutputPath => _tempDirectory.Path;
+
+        public async Task RestoreAsync()
+        {
+            await LazyInitializer.EnsureInitialized(ref _initialization, ref _sync, InitializeAsync);
+            logger.WriteLine("Restoring...");
+            string dotnetArgs = $"restore {project} -s {NuGetOrgPackages} -s {LocalPackages} -p:SdkVersion={SdkVersion}";
+            Stopwatch stopwatch = Stopwatch.StartNew();
+            int? exitCode = await ProcessWrapper.RunProcessAsync(DotNetExecutable, dotnetArgs, log: logger.WriteLine);
+            Assert.True(exitCode.HasValue && exitCode.Value == 0);
+            logger.WriteLine($"Done. ({stopwatch.ElapsedMilliseconds} ms)");
+        }
+
+        public async Task BuildAsync(string additionalParams = null, bool restore = true)
+        {
+            await LazyInitializer.EnsureInitialized(ref _initialization, ref _sync, InitializeAsync);
+
+            Stopwatch stopwatch = Stopwatch.StartNew();
+            logger.WriteLine("Building...");
+            string dotnetArgs = $"build {project} -c {Configuration} -o {OutputPath} -p:SdkVersion={SdkVersion} {additionalParams}";
+
+            if (!restore)
+            {
+                dotnetArgs += " --no-restore";
+            }
+
+            if (Debugger.IsAttached)
+            {
+                dotnetArgs += " -bl";
+            }
+
+            int? exitCode = await ProcessWrapper.RunProcessAsync(DotNetExecutable, dotnetArgs, log: logger.WriteLine);
+            Assert.True(exitCode.HasValue && exitCode.Value == 0);
+            logger.WriteLine($"Done. ({stopwatch.ElapsedMilliseconds} ms)");
+        }
+
+        public async Task PublishAsync(string additionalParams = null, bool restore = true)
+        {
+            await LazyInitializer.EnsureInitialized(ref _initialization, ref _sync, InitializeAsync);
+
+            Stopwatch stopwatch = Stopwatch.StartNew();
+            logger.WriteLine($"Publishing...");
+            string dotnetArgs = $"publish {project} -c {Configuration} -o {OutputPath} -p:SdkVersion={SdkVersion} {additionalParams}";
+
+            if (!restore)
+            {
+                dotnetArgs += " --no-restore";
+            }
+
+            if (Debugger.IsAttached)
+            {
+                dotnetArgs += " -bl";
+            }
+
+            int? exitCode = await ProcessWrapper.RunProcessAsync(DotNetExecutable, dotnetArgs, log: logger.WriteLine);
+            Assert.True(exitCode.HasValue && exitCode.Value == 0);
+            logger.WriteLine($"Done. ({stopwatch.ElapsedMilliseconds} ms)");
+        }
+
+        private async Task InitializeAsync()
+        {
+            logger.WriteLine($"Packing {SdkBuildProj} with version {SdkVersion}");
+            string arguments = $"pack {SdkBuildProj} -c {Configuration} -o {LocalPackages} -p:Version={SdkVersion}";
+
+            int? exitCode = await ProcessWrapper.RunProcessAsync(DotNetExecutable, arguments, SrcRoot, logger.WriteLine);
+            Assert.True(exitCode.HasValue && exitCode.Value == 0);
+        }
+
+        public void Dispose() => _tempDirectory.Dispose();
+    }
+}
diff --git a/test/Sdk.E2ETests/PublishTests.cs b/test/Sdk.E2ETests/PublishTests.cs
diff --git a/test/Sdk.E2ETests/TempDirectory.cs b/test/Sdk.E2ETests/TempDirectory.cs
diff --git a/test/Sdk.E2ETests/TestUtility.cs b/test/Sdk.E2ETests/TestUtility.cs
diff --git a/test/Sdk.E2ETests/ZipDeployTests.cs b/test/Sdk.E2ETests/ZipDeployTests.cs

Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,8 @@ public class GenerateFunctionMetadata : Task`
`26`	`26`
`27`	`27`	`public string? ExtensionsCsProjFilePath { get; set; }`
`28`	`28`
	`29`	`+ public bool WriteMetadataFile { get; set; } = true;`
	`30`	`+`
`29`	`31`	`[Required]`
`30`	`32`	`public ITaskItem[]? ReferencePaths { get; set; }`
`31`	`33`
`@@ -67,11 +69,18 @@ public override bool Execute()`
`67`	`69`
`68`	`70`	`private void WriteMetadataWithRetry(IEnumerable<SdkFunctionMetadata> functions)`
`69`	`71`	`{`
	`72`	`+ if (!WriteMetadataFile)`
	`73`	`+ {`
	`74`	`+ Log.LogMessage("Skipping writing function metadata file.");`
	`75`	`+ return;`
	`76`	`+ }`
	`77`	`+`
`70`	`78`	`int attempt = 0;`
`71`	`79`	`while (attempt < 10)`
`72`	`80`	`{`
`73`	`81`	`try`
`74`	`82`	`{`
	`83`	`+ Log.LogMessage($"Writing function metadata to {OutputPath} directory.");`
`75`	`84`	`FunctionMetadataJsonWriter.WriteMetadata(functions, OutputPath!);`
`76`	`85`	`break;`
`77`	`86`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,11 +17,11 @@ namespace Microsoft.Azure.Functions.Tests.E2ETests`
`17`	`17`	`{`
`18`	`18`	`public class FunctionAppFixture : IAsyncLifetime`
`19`	`19`	`{`
	`20`	`+ private readonly string _testApp = Constants.TestAppNames.E2EApp;`
`20`	`21`	`private readonly ILogger _logger;`
`21`	`22`	`private bool _disposed;`
`22`	`23`	`private Process _funcProcess;`
`23`	`24`	`private JobObjectRegistry _jobObjectRegistry;`
`24`		`- private string _testApp = Constants.TestAppNames.E2EApp;`
`25`	`25`
`26`	`26`	`public FunctionAppFixture(IMessageSink messageSink)`
`27`	`27`	`{`
`@@ -32,7 +32,8 @@ public FunctionAppFixture(IMessageSink messageSink)`
`32`	`32`	`_logger = loggerFactory.CreateLogger<FunctionAppFixture>();`
`33`	`33`	`}`
`34`	`34`
`35`		`- internal FunctionAppFixture(IMessageSink messageSink, string testApp) : this(messageSink)`
	`35`	`+ internal FunctionAppFixture(IMessageSink messageSink, string testApp)`
	`36`	`+ : this(messageSink)`
`36`	`37`	`{`
`37`	`38`	`_testApp = testApp;`
`38`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,26 +6,27 @@`
`6`	`6`	`using System.Text;`
`7`	`7`	`using System.Threading;`
`8`	`8`	`using System.Threading.Tasks;`
`9`		`-using Xunit.Abstractions;`
`10`	`9`
`11`	`10`	`namespace Microsoft.Azure.Functions.Sdk.E2ETests`
`12`	`11`	`{`
`13`		`- public class ProcessWrapper`
	`12`	`+ public static class ProcessWrapper`
`14`	`13`	`{`
`15`		`-`
`16`		`- public async Task<int?> RunProcess(string fileName, string arguments, string workingDirectory, ITestOutputHelper testOutputHelper = null)`
	`14`	`+ public static async Task<int?> RunProcessAsync(`
	`15`	`+ string fileName, string arguments, string workingDirectory = null, Action<string> log = null)`
`17`	`16`	`{`
`18`		`- return await RunProcessInternal(fileName, arguments, workingDirectory, testOutputHelper);`
	`17`	`+ return await RunProcessInternalAsync(fileName, arguments, workingDirectory, log);`
`19`	`18`	`}`
`20`	`19`
`21`		`- public async Task<Tuple<int?, string>> RunProcessForOutput(string fileName, string arguments, string workingDirectory, ITestOutputHelper testOutputHelper = null)`
	`20`	`+ public static async Task<Tuple<int?, string>> RunProcessForOutputAsync(`
	`21`	`+ string fileName, string arguments, string workingDirectory = null, Action<string> log = null)`
`22`	`22`	`{`
`23`	`23`	`StringBuilder processOutputStringBuilder = new StringBuilder();`
`24`		`- var exitCode = await RunProcessInternal(fileName, arguments, workingDirectory, testOutputHelper, processOutputStringBuilder);`
	`24`	`+ var exitCode = await RunProcessInternalAsync(fileName, arguments, workingDirectory, log, processOutputStringBuilder);`
`25`	`25`	`return new Tuple<int?,string>(exitCode, processOutputStringBuilder.ToString());`
`26`	`26`	`}`
`27`	`27`
`28`		`- private async Task<int?> RunProcessInternal(string fileName, string arguments, string workingDirectory, ITestOutputHelper testOutputHelper = null, StringBuilder processOutputBuilder = null)`
	`28`	`+ private static async Task<int?> RunProcessInternalAsync(`
	`29`	`+ string fileName, string arguments, string workingDirectory = null, Action<string> log = null, StringBuilder processOutputBuilder = null)`
`29`	`30`	`{`
`30`	`31`
`31`	`32`	`SemaphoreSlim processExitSemaphore = new SemaphoreSlim(0, 1);`
`@@ -53,23 +54,17 @@ public class ProcessWrapper`
`53`	`54`	`{`
`54`	`55`	`if (o.Data != null)`
`55`	`56`	`{`
`56`		`- testOutputHelper.WriteLine($"[{DateTime.UtcNow:O}] Error: {o.Data}");`
`57`		`- if (processOutputBuilder != null)`
`58`		`- {`
`59`		`- processOutputBuilder.AppendLine(o.Data);`
`60`		`- }`
	`57`	`+ log?.Invoke($"[{DateTime.UtcNow:O}] Error: {o.Data}");`
	`58`	`+ processOutputBuilder?.AppendLine(o.Data);`
`61`	`59`	`}`
`62`	`60`	`};`
`63`	`61`
`64`	`62`	`testProcess.OutputDataReceived += (s, o) =>`
`65`	`63`	`{`
`66`	`64`	`if (o.Data != null)`
`67`	`65`	`{`
`68`		`- testOutputHelper.WriteLine($"[{DateTime.UtcNow:O}] {o.Data}");`
`69`		`- if (processOutputBuilder != null)`
`70`		`- {`
`71`		`- processOutputBuilder.AppendLine(o.Data);`
`72`		`- }`
	`66`	`+ log?.Invoke($"[{DateTime.UtcNow:O}] {o.Data}");`
	`67`	`+ processOutputBuilder?.AppendLine(o.Data);`
`73`	`68`	`}`
`74`	`69`	`};`
`75`	`70`
`@@ -81,7 +76,7 @@ public class ProcessWrapper`
`81`	`76`	`int wait = 3 * 60 * 1000;`
`82`	`77`	`if (!await processExitSemaphore.WaitAsync(wait))`
`83`	`78`	`{`
`84`		`- testOutputHelper?.WriteLine($"Process '{testProcess.Id}' did not exit in {wait}ms.");`
	`79`	`+ log?.Invoke($"Process '{testProcess.Id}' did not exit in {wait}ms.");`
`85`	`80`	`testProcess.Kill();`
`86`	`81`	`}`
`87`	`82`