Remove ITestOutputHelper usage

ahmelsayed · ahmelsayed · commit 23a13295f5ca · 2018-07-20T12:19:12.000-07:00
diff --git a/src/Azure.Functions.Cli/Actions/DeployActions/DeployFunctionAction.cs b/src/Azure.Functions.Cli/Actions/DeployActions/DeployFunctionAction.cs
@@ -89,6 +89,12 @@ public override async Task RunAsync()
                 return;
             }
 
+            if (!CommandChecker.CommandExists("kubectl"))
+            {
+                ColoredConsole.Error.WriteLine(ErrorColor($"kubectl is required for deploying to kubernetes. Please make sure to install kubectl and try again."));
+                return;
+            }
+
             var dockerFilePath = Path.Combine(Environment.CurrentDirectory, "Dockerfile");
 
             if (!FileSystemHelpers.FileExists(dockerFilePath))
diff --git a/src/Azure.Functions.Cli/Common/Executable.cs b/src/Azure.Functions.Cli/Common/Executable.cs
@@ -87,13 +87,14 @@ public async Task<int> RunAsync(Action<string> outputCallback = null, Action<str
             else
             {
                 await Task.WhenAny(exitCodeTask, Task.Delay(timeout.Value));
-                if (!exitCodeTask.IsCompleted)
+                if (exitCodeTask.IsCompleted)
                 {
-                    throw new Exception("Process didn't exit within specified timeout");
+                    return exitCodeTask.Result;
                 }
                 else
                 {
-                    return await exitCodeTask;
+                    Process.Kill();
+                    throw new Exception("Process didn't exit within specified timeout");
                 }
             }
         }
diff --git a/src/Azure.Functions.Cli/StaticResources/Dockerfile.dotnet.template b/src/Azure.Functions.Cli/StaticResources/Dockerfile.dotnet.template
@@ -1,3 +1,11 @@
+FROM microsoft/dotnet:2.1-sdk AS installer-env
+
+COPY . /src/dotnet-function-app
+RUN cd /src/dotnet-function-app && \
+    mkdir -p /home/site/wwwroot && \
+    dotnet publish *.csproj --output /home/site/wwwroot
+
 FROM microsoft/azure-functions-dotnet-core2.0:2.0
 ENV AzureWebJobsScriptRoot=/home/site/wwwroot
-COPY . /home/site/wwwroot
+
+COPY --from=installer-env ["/home/site/wwwroot", "/home/site/wwwroot"]
diff --git a/src/Azure.Functions.Cli/StaticResources/Dockerfile.python.template b/src/Azure.Functions.Cli/StaticResources/Dockerfile.python.template
@@ -5,6 +5,4 @@ FROM microsoft/azure-functions-python3.6:2.0
 COPY . /home/site/wwwroot
 
 RUN cd /home/site/wwwroot && \
-    /bin/bash -c \
-    "source /workers/worker_env/bin/activate &&\
-    pip3 install -r requirements.txt"
+    pip install -r requirements.txt
diff --git a/test/Azure.Functions.Cli.Tests/E2E/Helpers/CliTester.cs b/test/Azure.Functions.Cli.Tests/E2E/Helpers/CliTester.cs
@@ -7,22 +7,21 @@
 using Azure.Functions.Cli.Common;
 using FluentAssertions;
 using Xunit;
-using Xunit.Abstractions;
 
 namespace Azure.Functions.Cli.Tests.E2E.Helpers
 {
     public static class CliTester
     {
         private static string _func = System.Environment.GetEnvironmentVariable("FUNC_PATH");
-        public static Task Run(RunConfiguration runConfiguration, ITestOutputHelper output) => Run(new[] { runConfiguration }, output);
+        public static Task Run(RunConfiguration runConfiguration) => Run(new[] { runConfiguration });
 
-        public static async Task Run(RunConfiguration[] runConfigurations, ITestOutputHelper output)
+        public static async Task Run(RunConfiguration[] runConfigurations)
         {
             var tempDir = Path.Combine(Path.GetTempPath(), Path.GetTempFileName().Replace(".", ""));
             Directory.CreateDirectory(tempDir);
             try
             {
-                await InternalRun(tempDir, runConfigurations, output);
+                await InternalRun(tempDir, runConfigurations);
             }
             finally
             {
@@ -34,19 +33,21 @@ public static async Task Run(RunConfiguration[] runConfigurations, ITestOutputHe
             }
         }
 
-        private static async Task InternalRun(string workingDir, RunConfiguration[] runConfigurations, ITestOutputHelper output)
+        private static async Task InternalRun(string workingDir, RunConfiguration[] runConfigurations)
         {
+            var stdout = new StringBuilder();
+            var stderr = new StringBuilder();
             foreach (var runConfiguration in runConfigurations)
             {
-                var stdout = new StringBuilder();
-                var stderr = new StringBuilder();
+                stdout.Clear();
+                stderr.Clear();
                 var exitError = false;
 
                 for (var i = 0; i < runConfiguration.Commands.Length; i++)
                 {
                     var command = runConfiguration.Commands[i];
                     var exe = new Executable(_func, command, workingDirectory: workingDir);
-                    output.WriteLine($"Running: > {exe.Command}");
+                    Console.WriteLine($"Running: > {exe.Command}");
                     if (runConfiguration.ExpectExit || (i + 1) < runConfiguration.Commands.Length)
                     {
                         var exitCode = await exe.RunAsync(logStd, logErr, timeout: runConfiguration.CommandTimeout);
@@ -81,23 +82,22 @@ private static async Task InternalRun(string workingDir, RunConfiguration[] runC
                 }
 
                 AssertExitError(runConfiguration, exitError);
-                // AssertHasStandardError(runConfiguration, stderr);
                 AssertFiles(runConfiguration, workingDir);
                 AssertDirectories(runConfiguration, workingDir);
                 AssertOutputContent(runConfiguration, stdout);
                 AssertErrorContent(runConfiguration, stderr);
 
-                void logStd(string line)
-                {
-                    stdout.AppendLine(line);
-                    output.WriteLine($"stdout: {line}");
-                }
+            }
+            void logStd(string line)
+            {
+                stdout.AppendLine(line);
+                Console.WriteLine($"stdout: {line}");
+            }
 
-                void logErr(string line)
-                {
-                    stderr.AppendLine(line);
-                    output.WriteLine($"stderr: {line}");
-                }
+            void logErr(string line)
+            {
+                stderr.AppendLine(line);
+                Console.WriteLine($"stderr: {line}");
             }
         }
 
diff --git a/test/Azure.Functions.Cli.Tests/E2E/InitTests.cs b/test/Azure.Functions.Cli.Tests/E2E/InitTests.cs
@@ -6,14 +6,11 @@
 using System.Threading.Tasks;
 using Azure.Functions.Cli.Tests.E2E.Helpers;
 using Xunit;
-using Xunit.Abstractions;
 
 namespace Azure.Functions.Cli.Tests.E2E
 {
-    public class InitTests : BaseE2ETest
+    public class InitTests
     {
-        public InitTests(ITestOutputHelper output) : base(output) { }
-
         [Theory]
         [InlineData("node")]
         [InlineData("java")]
@@ -42,7 +39,7 @@ public Task init_with_worker_runtime(string workerRuntime)
                     $".vscode{Path.DirectorySeparatorChar}extensions.json",
                 },
                 OutputDoesntContain = new[] { "Initialized empty Git repository" }
-            }, _output);
+            });
         }
 
         [Fact]
@@ -56,7 +53,7 @@ public Task init_python_app_expect_error()
                 {
                     "For Python function apps, you have to be running in a venv."
                 }
-            }, _output);
+            });
         }
 
         [Fact]
@@ -89,7 +86,7 @@ public Task init_dotnet_app()
                         }
                     }
                 }
-            }, _output);
+            });
         }
 
         [Fact]
@@ -104,7 +101,7 @@ public Task init_with_unknown_worker_runtime()
                 {
                     $"Worker runtime '{unknownWorkerRuntime}' is not a valid option."
                 }
-            }, _output);
+            });
         }
 
         [Fact]
@@ -117,7 +114,7 @@ public Task init_with_no_source_control()
                 {
                     new DirectoryResult { Name = ".git", Exists = false }
                 },
-            }, _output);
+            });
         }
 
         [Theory]
@@ -127,7 +124,7 @@ public Task init_with_Dockerfile(string workerRuntime)
         {
             return CliTester.Run(new RunConfiguration
             {
-                Commands = new[] { $"init . --worker-runtime {workerRuntime} --docker" },
+                Commands = new[] { $"init . --worker-runtime {workerRuntime} --no-source-control --docker" },
                 CheckFiles = new[]
                 {
                     new FileResult
@@ -137,15 +134,15 @@ public Task init_with_Dockerfile(string workerRuntime)
                     }
                 },
                 OutputContains = new[] { "Dockerfile" }
-            }, _output);
+            });
         }
 
         [Fact]
         public Task init_csx_app()
         {
             return CliTester.Run(new RunConfiguration
             {
-                Commands = new[] { "init . --worker-runtime dotnet --csx" },
+                Commands = new[] { "init . --worker-runtime dotnet --no-source-control --csx" },
                 CheckFiles = new FileResult[]
                 {
                     new FileResult
@@ -165,7 +162,7 @@ public Task init_csx_app()
                     "Writing local.settings.json",
                     $".vscode{Path.DirectorySeparatorChar}extensions.json",
                 }
-            }, _output);
+            });
         }
     }
 }
diff --git a/test/Azure.Functions.Cli.Tests/E2E/SettingsTests.cs b/test/Azure.Functions.Cli.Tests/E2E/SettingsTests.cs
@@ -3,14 +3,11 @@
 using System.Threading.Tasks;
 using Azure.Functions.Cli.Tests.E2E.Helpers;
 using Xunit;
-using Xunit.Abstractions;
 
 namespace Azure.Functions.Cli.Tests.E2E
 {
-    public class SettingsTests : BaseE2ETest
+    public class SettingsTests
     {
-        public SettingsTests(ITestOutputHelper output) : base(output) { }
-
         [Fact]
         public Task add_setting_plain_text()
         {
@@ -33,7 +30,7 @@ public Task add_setting_plain_text()
                         }
                     }
                 }
-            }, _output);
+            });
         }
 
         [Fact]
@@ -85,7 +82,7 @@ public Task add_setting_encrypted()
                         }
                     }
                 }
-            }, _output);
+            });
         }
     }
 }
diff --git a/test/Azure.Functions.Cli.Tests/E2E/StartTests.cs b/test/Azure.Functions.Cli.Tests/E2E/StartTests.cs
@@ -2,28 +2,25 @@
 using System.IO;
 using System.Collections.Generic;
 using System.Linq;
+using System.Net.Http;
 using System.Text;
 using System.Threading.Tasks;
 using Azure.Functions.Cli.Tests.E2E.Helpers;
-using Xunit;
-using Xunit.Abstractions;
-using System.Net.Http;
 using FluentAssertions;
+using Xunit;
 
 namespace Azure.Functions.Cli.Tests.E2E
 {
-    public class StartTests : BaseE2ETest
+    public class StartTests
     {
-        public StartTests(ITestOutputHelper output) : base(output) { }
-
         [Fact]
         public Task start_nodejs()
         {
             return CliTester.Run(new RunConfiguration
             {
                 Commands = new[]
                 {
-                    "init . --worker-runtime node",
+                    "init . --worker-runtime node --no-source-control",
                     "new --template \"Http trigger\" --name HttpTrigger",
                     "start"
                 },
@@ -40,7 +37,7 @@ public Task start_nodejs()
                         result.Should().Be("Hello Test", because: "response from default function should be 'Hello {name}'");
                     }
                 },
-            }, _output);
+            });
         }
 
         [Fact]
@@ -63,10 +60,11 @@ public Task start_dotnet_csharp()
                         var response = await client.GetAsync("/api/HttpTrigger?name=Test");
                         var result = await response.Content.ReadAsStringAsync();
                         p.Kill();
+                        await Task.Delay(TimeSpan.FromSeconds(2));
                         result.Should().Be("Hello, Test", because: "response from default function should be 'Hello, {name}'");
                     }
                 },
-            }, _output);
+            });
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -87,13 +87,14 @@ public async Task<int> RunAsync(Action<string> outputCallback = null, Action<str`
`87`	`87`	`else`
`88`	`88`	`{`
`89`	`89`	`await Task.WhenAny(exitCodeTask, Task.Delay(timeout.Value));`
`90`		`- if (!exitCodeTask.IsCompleted)`
	`90`	`+ if (exitCodeTask.IsCompleted)`
`91`	`91`	`{`
`92`		`- throw new Exception("Process didn't exit within specified timeout");`
	`92`	`+ return exitCodeTask.Result;`
`93`	`93`	`}`
`94`	`94`	`else`
`95`	`95`	`{`
`96`		`- return await exitCodeTask;`
	`96`	`+ Process.Kill();`
	`97`	`+ throw new Exception("Process didn't exit within specified timeout");`
`97`	`98`	`}`
`98`	`99`	`}`
`99`	`100`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,22 +7,21 @@`
`7`	`7`	`using Azure.Functions.Cli.Common;`
`8`	`8`	`using FluentAssertions;`
`9`	`9`	`using Xunit;`
`10`		`-using Xunit.Abstractions;`
`11`	`10`
`12`	`11`	`namespace Azure.Functions.Cli.Tests.E2E.Helpers`
`13`	`12`	`{`
`14`	`13`	`public static class CliTester`
`15`	`14`	`{`
`16`	`15`	`private static string _func = System.Environment.GetEnvironmentVariable("FUNC_PATH");`
`17`		`- public static Task Run(RunConfiguration runConfiguration, ITestOutputHelper output) => Run(new[] { runConfiguration }, output);`
	`16`	`+ public static Task Run(RunConfiguration runConfiguration) => Run(new[] { runConfiguration });`
`18`	`17`
`19`		`- public static async Task Run(RunConfiguration[] runConfigurations, ITestOutputHelper output)`
	`18`	`+ public static async Task Run(RunConfiguration[] runConfigurations)`
`20`	`19`	`{`
`21`	`20`	`var tempDir = Path.Combine(Path.GetTempPath(), Path.GetTempFileName().Replace(".", ""));`
`22`	`21`	`Directory.CreateDirectory(tempDir);`
`23`	`22`	`try`
`24`	`23`	`{`
`25`		`- await InternalRun(tempDir, runConfigurations, output);`
	`24`	`+ await InternalRun(tempDir, runConfigurations);`
`26`	`25`	`}`
`27`	`26`	`finally`
`28`	`27`	`{`
`@@ -34,19 +33,21 @@ public static async Task Run(RunConfiguration[] runConfigurations, ITestOutputHe`
`34`	`33`	`}`
`35`	`34`	`}`
`36`	`35`
`37`		`- private static async Task InternalRun(string workingDir, RunConfiguration[] runConfigurations, ITestOutputHelper output)`
	`36`	`+ private static async Task InternalRun(string workingDir, RunConfiguration[] runConfigurations)`
`38`	`37`	`{`
	`38`	`+ var stdout = new StringBuilder();`
	`39`	`+ var stderr = new StringBuilder();`
`39`	`40`	`foreach (var runConfiguration in runConfigurations)`
`40`	`41`	`{`
`41`		`- var stdout = new StringBuilder();`
`42`		`- var stderr = new StringBuilder();`
	`42`	`+ stdout.Clear();`
	`43`	`+ stderr.Clear();`
`43`	`44`	`var exitError = false;`
`44`	`45`
`45`	`46`	`for (var i = 0; i < runConfiguration.Commands.Length; i++)`
`46`	`47`	`{`
`47`	`48`	`var command = runConfiguration.Commands[i];`
`48`	`49`	`var exe = new Executable(_func, command, workingDirectory: workingDir);`
`49`		`- output.WriteLine($"Running: > {exe.Command}");`
	`50`	`+ Console.WriteLine($"Running: > {exe.Command}");`
`50`	`51`	`if (runConfiguration.ExpectExit \|\| (i + 1) < runConfiguration.Commands.Length)`
`51`	`52`	`{`
`52`	`53`	`var exitCode = await exe.RunAsync(logStd, logErr, timeout: runConfiguration.CommandTimeout);`
`@@ -81,23 +82,22 @@ private static async Task InternalRun(string workingDir, RunConfiguration[] runC`
`81`	`82`	`}`
`82`	`83`
`83`	`84`	`AssertExitError(runConfiguration, exitError);`
`84`		`- // AssertHasStandardError(runConfiguration, stderr);`
`85`	`85`	`AssertFiles(runConfiguration, workingDir);`
`86`	`86`	`AssertDirectories(runConfiguration, workingDir);`
`87`	`87`	`AssertOutputContent(runConfiguration, stdout);`
`88`	`88`	`AssertErrorContent(runConfiguration, stderr);`
`89`	`89`
`90`		`- void logStd(string line)`
`91`		`- {`
`92`		`- stdout.AppendLine(line);`
`93`		`- output.WriteLine($"stdout: {line}");`
`94`		`- }`
	`90`	`+ }`
	`91`	`+ void logStd(string line)`
	`92`	`+ {`
	`93`	`+ stdout.AppendLine(line);`
	`94`	`+ Console.WriteLine($"stdout: {line}");`
	`95`	`+ }`
`95`	`96`
`96`		`- void logErr(string line)`
`97`		`- {`
`98`		`- stderr.AppendLine(line);`
`99`		`- output.WriteLine($"stderr: {line}");`
`100`		`- }`
	`97`	`+ void logErr(string line)`
	`98`	`+ {`
	`99`	`+ stderr.AppendLine(line);`
	`100`	`+ Console.WriteLine($"stderr: {line}");`
`101`	`101`	`}`
`102`	`102`	`}`
`103`	`103`
Original file line number	Diff line number	Diff line change
`@@ -6,14 +6,11 @@`
`6`	`6`	`using System.Threading.Tasks;`
`7`	`7`	`using Azure.Functions.Cli.Tests.E2E.Helpers;`
`8`	`8`	`using Xunit;`
`9`		`-using Xunit.Abstractions;`
`10`	`9`
`11`	`10`	`namespace Azure.Functions.Cli.Tests.E2E`
`12`	`11`	`{`
`13`		`- public class InitTests : BaseE2ETest`
	`12`	`+ public class InitTests`
`14`	`13`	`{`
`15`		`- public InitTests(ITestOutputHelper output) : base(output) { }`
`16`		`-`
`17`	`14`	`[Theory]`
`18`	`15`	`[InlineData("node")]`
`19`	`16`	`[InlineData("java")]`
`@@ -42,7 +39,7 @@ public Task init_with_worker_runtime(string workerRuntime)`
`42`	`39`	`$".vscode{Path.DirectorySeparatorChar}extensions.json",`
`43`	`40`	`},`
`44`	`41`	`OutputDoesntContain = new[] { "Initialized empty Git repository" }`
`45`		`- }, _output);`
	`42`	`+ });`
`46`	`43`	`}`
`47`	`44`
`48`	`45`	`[Fact]`
`@@ -56,7 +53,7 @@ public Task init_python_app_expect_error()`
`56`	`53`	`{`
`57`	`54`	`"For Python function apps, you have to be running in a venv."`
`58`	`55`	`}`
`59`		`- }, _output);`
	`56`	`+ });`
`60`	`57`	`}`
`61`	`58`
`62`	`59`	`[Fact]`
`@@ -89,7 +86,7 @@ public Task init_dotnet_app()`
`89`	`86`	`}`
`90`	`87`	`}`
`91`	`88`	`}`
`92`		`- }, _output);`
	`89`	`+ });`
`93`	`90`	`}`
`94`	`91`
`95`	`92`	`[Fact]`
`@@ -104,7 +101,7 @@ public Task init_with_unknown_worker_runtime()`
`104`	`101`	`{`
`105`	`102`	`$"Worker runtime '{unknownWorkerRuntime}' is not a valid option."`
`106`	`103`	`}`
`107`		`- }, _output);`
	`104`	`+ });`
`108`	`105`	`}`
`109`	`106`
`110`	`107`	`[Fact]`
`@@ -117,7 +114,7 @@ public Task init_with_no_source_control()`
`117`	`114`	`{`
`118`	`115`	`new DirectoryResult { Name = ".git", Exists = false }`
`119`	`116`	`},`
`120`		`- }, _output);`
	`117`	`+ });`
`121`	`118`	`}`
`122`	`119`
`123`	`120`	`[Theory]`
`@@ -127,7 +124,7 @@ public Task init_with_Dockerfile(string workerRuntime)`
`127`	`124`	`{`
`128`	`125`	`return CliTester.Run(new RunConfiguration`
`129`	`126`	`{`
`130`		`- Commands = new[] { $"init . --worker-runtime {workerRuntime} --docker" },`
	`127`	`+ Commands = new[] { $"init . --worker-runtime {workerRuntime} --no-source-control --docker" },`
`131`	`128`	`CheckFiles = new[]`
`132`	`129`	`{`
`133`	`130`	`new FileResult`
`@@ -137,15 +134,15 @@ public Task init_with_Dockerfile(string workerRuntime)`
`137`	`134`	`}`
`138`	`135`	`},`
`139`	`136`	`OutputContains = new[] { "Dockerfile" }`
`140`		`- }, _output);`
	`137`	`+ });`
`141`	`138`	`}`
`142`	`139`
`143`	`140`	`[Fact]`
`144`	`141`	`public Task init_csx_app()`
`145`	`142`	`{`
`146`	`143`	`return CliTester.Run(new RunConfiguration`
`147`	`144`	`{`
`148`		`- Commands = new[] { "init . --worker-runtime dotnet --csx" },`
	`145`	`+ Commands = new[] { "init . --worker-runtime dotnet --no-source-control --csx" },`
`149`	`146`	`CheckFiles = new FileResult[]`
`150`	`147`	`{`
`151`	`148`	`new FileResult`
`@@ -165,7 +162,7 @@ public Task init_csx_app()`
`165`	`162`	`"Writing local.settings.json",`
`166`	`163`	`$".vscode{Path.DirectorySeparatorChar}extensions.json",`
`167`	`164`	`}`
`168`		`- }, _output);`
	`165`	`+ });`
`169`	`166`	`}`
`170`	`167`	`}`
`171`	`168`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,14 +3,11 @@`
`3`	`3`	`using System.Threading.Tasks;`
`4`	`4`	`using Azure.Functions.Cli.Tests.E2E.Helpers;`
`5`	`5`	`using Xunit;`
`6`		`-using Xunit.Abstractions;`
`7`	`6`
`8`	`7`	`namespace Azure.Functions.Cli.Tests.E2E`
`9`	`8`	`{`
`10`		`- public class SettingsTests : BaseE2ETest`
	`9`	`+ public class SettingsTests`
`11`	`10`	`{`
`12`		`- public SettingsTests(ITestOutputHelper output) : base(output) { }`
`13`		`-`
`14`	`11`	`[Fact]`
`15`	`12`	`public Task add_setting_plain_text()`
`16`	`13`	`{`
`@@ -33,7 +30,7 @@ public Task add_setting_plain_text()`
`33`	`30`	`}`
`34`	`31`	`}`
`35`	`32`	`}`
`36`		`- }, _output);`
	`33`	`+ });`
`37`	`34`	`}`
`38`	`35`
`39`	`36`	`[Fact]`
`@@ -85,7 +82,7 @@ public Task add_setting_encrypted()`
`85`	`82`	`}`
`86`	`83`	`}`
`87`	`84`	`}`
`88`		`- }, _output);`
	`85`	`+ });`
`89`	`86`	`}`
`90`	`87`	`}`
`91`	`88`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,28 +2,25 @@`
`2`	`2`	`using System.IO;`
`3`	`3`	`using System.Collections.Generic;`
`4`	`4`	`using System.Linq;`
	`5`	`+using System.Net.Http;`
`5`	`6`	`using System.Text;`
`6`	`7`	`using System.Threading.Tasks;`
`7`	`8`	`using Azure.Functions.Cli.Tests.E2E.Helpers;`
`8`		`-using Xunit;`
`9`		`-using Xunit.Abstractions;`
`10`		`-using System.Net.Http;`
`11`	`9`	`using FluentAssertions;`
	`10`	`+using Xunit;`
`12`	`11`
`13`	`12`	`namespace Azure.Functions.Cli.Tests.E2E`
`14`	`13`	`{`
`15`		`- public class StartTests : BaseE2ETest`
	`14`	`+ public class StartTests`
`16`	`15`	`{`
`17`		`- public StartTests(ITestOutputHelper output) : base(output) { }`
`18`		`-`
`19`	`16`	`[Fact]`
`20`	`17`	`public Task start_nodejs()`
`21`	`18`	`{`
`22`	`19`	`return CliTester.Run(new RunConfiguration`
`23`	`20`	`{`
`24`	`21`	`Commands = new[]`
`25`	`22`	`{`
`26`		`- "init . --worker-runtime node",`
	`23`	`+ "init . --worker-runtime node --no-source-control",`
`27`	`24`	`"new --template \"Http trigger\" --name HttpTrigger",`
`28`	`25`	`"start"`
`29`	`26`	`},`
`@@ -40,7 +37,7 @@ public Task start_nodejs()`
`40`	`37`	`result.Should().Be("Hello Test", because: "response from default function should be 'Hello {name}'");`
`41`	`38`	`}`
`42`	`39`	`},`
`43`		`- }, _output);`
	`40`	`+ });`
`44`	`41`	`}`
`45`	`42`
`46`	`43`	`[Fact]`
`@@ -63,10 +60,11 @@ public Task start_dotnet_csharp()`
`63`	`60`	`var response = await client.GetAsync("/api/HttpTrigger?name=Test");`
`64`	`61`	`var result = await response.Content.ReadAsStringAsync();`
`65`	`62`	`p.Kill();`
	`63`	`+ await Task.Delay(TimeSpan.FromSeconds(2));`
`66`	`64`	`result.Should().Be("Hello, Test", because: "response from default function should be 'Hello, {name}'");`
`67`	`65`	`}`
`68`	`66`	`},`
`69`		`- }, _output);`
	`67`	`+ });`
`70`	`68`	`}`
`71`	`69`	`}`
`72`	`70`	`}`