refactor: code deduplication and added/fixed tests for new hosting APIs (#415)

cbcrouse · hellfirehd · natemcmaster · web-flow · commit 643f9c35f79b · 2021-01-09T15:07:51.000-08:00
Co-authored-by: Doug Wilson &lt;d@dkw.io&gt;
Co-authored-by: Nate McMaster &lt;nate.mcmaster@gmail.com&gt;
diff --git a/README.md b/README.md
@@ -112,7 +112,7 @@ The library also includes other utilities for interaction with the console. Thes
      var args = new [] { "Arg1", "arg with space", "args ' with \" quotes" };
      Process.Start("echo", ArgumentEscaper.EscapeAndConcatenate(args));
     ```
- - `Prompt` - for getting feedback from users with a default answer.  
+ - `Prompt` - for getting feedback from users with a default answer.
    A few examples:
     ```c#
     // allows y/n responses, will return false by default in this case.
@@ -129,5 +129,3 @@ The library also includes other utilities for interaction with the console. Thes
     ```
 
 And more! See the [documentation](https://natemcmaster.github.io/CommandLineUtils/) for more API, such as `IConsole`, `IReporter`, and others.
-
-
diff --git a/src/Hosting.CommandLine/HostBuilderExtensions.cs b/src/Hosting.CommandLine/HostBuilderExtensions.cs
@@ -2,7 +2,6 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
-using System.Runtime.ExceptionServices;
 using System.Threading;
 using System.Threading.Tasks;
 using McMaster.Extensions.CommandLineUtils;
@@ -36,7 +35,7 @@ public static async Task<int> RunCommandLineApplicationAsync<TApp>(
             CancellationToken cancellationToken = default)
             where TApp : class
         {
-            return await RunCommandLineApplicationAsync<TApp>(hostBuilder, args, null, cancellationToken);
+            return await RunCommandLineApplicationAsync<TApp>(hostBuilder, args, app => { }, cancellationToken);
         }
 
         /// <summary>
@@ -57,40 +56,19 @@ public static async Task<int> RunCommandLineApplicationAsync<TApp>(
             CancellationToken cancellationToken = default)
             where TApp : class
         {
-            configure ??= app => { };
-            var exceptionHandler = new StoreExceptionHandler();
             var state = new CommandLineState(args);
             hostBuilder.Properties[typeof(CommandLineState)] = state;
             hostBuilder.ConfigureServices(
                 (context, services)
                     =>
                 {
-                    services
-                        .TryAddSingleton<IUnhandledExceptionHandler>(exceptionHandler);
-                    services
-                        .AddSingleton<IHostLifetime, CommandLineLifetime>()
-                        .TryAddSingleton(PhysicalConsole.Singleton);
-                    services
-                        .AddSingleton(provider =>
-                        {
-                            state.SetConsole(provider.GetService<IConsole>());
-                            return state;
-                        })
-                        .AddSingleton<CommandLineContext>(state)
-                        .AddSingleton<ICommandLineService, CommandLineService<TApp>>();
-                    services
-                        .AddSingleton(configure);
+                    services.AddCommonServices(state);
+                    services.AddSingleton<ICommandLineService, CommandLineService<TApp>>();
+                    services.AddSingleton(configure);
                 });
 
             using var host = hostBuilder.Build();
-            await host.RunAsync(cancellationToken);
-
-            if (exceptionHandler.StoredException != null)
-            {
-                ExceptionDispatchInfo.Capture(exceptionHandler.StoredException).Throw();
-            }
-
-            return state.ExitCode;
+            return await host.RunCommandLineApplicationAsync(cancellationToken);
         }
 
         /// <summary>
@@ -110,41 +88,33 @@ public static async Task<int> RunCommandLineApplicationAsync(
             Action<CommandLineApplication> configure,
             CancellationToken cancellationToken = default)
         {
-            var exceptionHandler = new StoreExceptionHandler();
             var state = new CommandLineState(args);
             hostBuilder.Properties[typeof(CommandLineState)] = state;
             hostBuilder.ConfigureServices(
                 (context, services)
                     =>
                 {
-                    services
-                        .TryAddSingleton<IUnhandledExceptionHandler>(exceptionHandler);
-                    services
-                        .AddSingleton<IHostLifetime, CommandLineLifetime>()
-                        .TryAddSingleton(PhysicalConsole.Singleton);
-                    services
-                        .AddSingleton(provider =>
-                        {
-                            state.SetConsole(provider.GetService<IConsole>());
-                            return state;
-                        })
-                        .AddSingleton<CommandLineContext>(state)
-                        .AddSingleton<ICommandLineService, CommandLineService>();
-                    services
-                        .AddSingleton(configure);
+                    services.AddCommonServices(state);
+                    services.AddSingleton<ICommandLineService, CommandLineService>();
+                    services.AddSingleton(configure);
                 });
 
             using var host = hostBuilder.Build();
+            return await host.RunCommandLineApplicationAsync(cancellationToken);
+        }
 
-            await host.RunAsync(cancellationToken);
-
-            if (exceptionHandler.StoredException != null)
-            {
-                ExceptionDispatchInfo.Capture(exceptionHandler.StoredException).Throw();
-            }
+        /// <summary>
+        ///     Configures an instance of <typeparamref name="TApp" /> using <see cref="CommandLineApplication" /> to provide
+        ///     command line parsing on the given <paramref name="args" />.
+        /// </summary>
+        /// <typeparam name="TApp">The type of the command line application implementation</typeparam>
+        /// <param name="hostBuilder">This instance</param>
+        /// <param name="args">The command line arguments</param>
+        /// <returns><see cref="IHostBuilder"/></returns>
+        public static IHostBuilder UseCommandLineApplication<TApp>(this IHostBuilder hostBuilder, string[] args)
+            where TApp : class
+            => UseCommandLineApplication<TApp>(hostBuilder, args, _ => { });
 
-            return state.ExitCode;
-        }
 
         /// <summary>
         ///     Configures an instance of <typeparamref name="TApp" /> using <see cref="CommandLineApplication" /> to provide
@@ -158,15 +128,14 @@ public static async Task<int> RunCommandLineApplicationAsync(
         public static IHostBuilder UseCommandLineApplication<TApp>(
             this IHostBuilder hostBuilder,
             string[] args,
-            Action<CommandLineApplication<TApp>> configure = null)
+            Action<CommandLineApplication<TApp>> configure)
             where TApp : class
         {
             configure ??= app => { };
             var state = new CommandLineState(args);
             hostBuilder.Properties[typeof(CommandLineState)] = state;
             hostBuilder.ConfigureServices(
-                (context, services)
-                    =>
+                (context, services) =>
                 {
                     services
                         .TryAddSingleton<StoreExceptionHandler>();
@@ -189,5 +158,23 @@ public static IHostBuilder UseCommandLineApplication<TApp>(
 
             return hostBuilder;
         }
+
+        private static void AddCommonServices(this IServiceCollection services, CommandLineState state)
+        {
+            services
+                .TryAddSingleton<StoreExceptionHandler>();
+            services
+                .TryAddSingleton<IUnhandledExceptionHandler>(provider => provider.GetRequiredService<StoreExceptionHandler>());
+            services
+                .AddSingleton<IHostLifetime, CommandLineLifetime>()
+                .TryAddSingleton(PhysicalConsole.Singleton);
+            services
+                .AddSingleton(provider =>
+                {
+                    state.SetConsole(provider.GetService<IConsole>());
+                    return state;
+                })
+                .AddSingleton<CommandLineContext>(state);
+        }
     }
 }
diff --git a/src/Hosting.CommandLine/HostExtensions.cs b/src/Hosting.CommandLine/HostExtensions.cs
@@ -17,16 +17,12 @@ namespace Microsoft.Extensions.Hosting
     public static class HostExtensions
     {
         /// <summary>
-        /// Runs an instance of <typeparamref name="TApp" /> using the <see cref="CommandLineApplication" /> previously configured in
+        /// Runs the app using the <see cref="CommandLineApplication" /> previously configured in
         /// <see cref="HostBuilderExtensions.UseCommandLineApplication{TApp}(IHostBuilder, string[], Action{CommandLineApplication{TApp}})"/>.
         /// </summary>
-        /// <typeparam name="TApp">The type of the command line application implementation</typeparam>
-        /// <param name="host">This instance</param>
-        /// <param name="cancellationToken">A cancellation token</param>
-        public static async Task<int> RunCommandLineApplicationAsync<TApp>(
-            this IHost host,
-            CancellationToken cancellationToken = default)
-            where TApp : class
+        /// <param name="host">A program abstraction.</param>
+        /// <param name="cancellationToken">Propagates notification that operations should be canceled.</param>
+        public static async Task<int> RunCommandLineApplicationAsync(this IHost host, CancellationToken cancellationToken = default)
         {
             var exceptionHandler = host.Services.GetService<StoreExceptionHandler>();
             var state = host.Services.GetRequiredService<CommandLineState>();
diff --git a/src/Hosting.CommandLine/PublicAPI.Unshipped.txt b/src/Hosting.CommandLine/PublicAPI.Unshipped.txt
@@ -1,4 +1,5 @@
 #nullable enable
-static Microsoft.Extensions.Hosting.HostBuilderExtensions.UseCommandLineApplication<TApp>(this Microsoft.Extensions.Hosting.IHostBuilder! hostBuilder, string![]! args, System.Action<McMaster.Extensions.CommandLineUtils.CommandLineApplication<TApp!>!>! configure = null) -> Microsoft.Extensions.Hosting.IHostBuilder!
 Microsoft.Extensions.Hosting.HostExtensions
-static Microsoft.Extensions.Hosting.HostExtensions.RunCommandLineApplicationAsync<TApp>(this Microsoft.Extensions.Hosting.IHost! host, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<int>!
+static Microsoft.Extensions.Hosting.HostBuilderExtensions.UseCommandLineApplication<TApp>(this Microsoft.Extensions.Hosting.IHostBuilder! hostBuilder, string![]! args) -> Microsoft.Extensions.Hosting.IHostBuilder!
+static Microsoft.Extensions.Hosting.HostBuilderExtensions.UseCommandLineApplication<TApp>(this Microsoft.Extensions.Hosting.IHostBuilder! hostBuilder, string![]! args, System.Action<McMaster.Extensions.CommandLineUtils.CommandLineApplication<TApp!>!>! configure) -> Microsoft.Extensions.Hosting.IHostBuilder!
+static Microsoft.Extensions.Hosting.HostExtensions.RunCommandLineApplicationAsync(this Microsoft.Extensions.Hosting.IHost! host, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<int>!
diff --git a/test/Hosting.CommandLine.Tests/CustomValueParserTests.cs b/test/Hosting.CommandLine.Tests/CustomValueParserTests.cs
@@ -31,8 +31,7 @@ public async Task ItParsesUsingCustomParserFromConfigAction()
                 .ConfigureServices(collection => collection.AddSingleton<IConsole>(new TestConsole(_output)))
                 .RunCommandLineApplicationAsync<CustomOptionTypeCommand>(
                     new[] { "--custom-type", DemoOptionValue },
-                    app => app.ValueParsers.AddOrReplace(
-                        new CustomValueParser()));
+                    app => app.ValueParsers.AddOrReplace(new CustomValueParser()));
             Assert.Equal(0, exitCode);
         }
 
diff --git a/test/Hosting.CommandLine.Tests/HostBuilderExtensionsAttributeAPITests.cs b/test/Hosting.CommandLine.Tests/HostBuilderExtensionsAttributeAPITests.cs
@@ -74,6 +74,29 @@ public async Task TestConfigureCommandLineApplication()
             Assert.NotNull(commandLineApp);
         }
 
+        [Fact]
+        public async Task TestUseCommandLineApplication()
+        {
+            CommandLineApplication<Return42Command> commandLineApp = default;
+            var hostBuilder = new HostBuilder();
+            hostBuilder.UseCommandLineApplication<Return42Command>(new string[0], app => commandLineApp = app);
+            var host = hostBuilder.Build();
+            await host.RunCommandLineApplicationAsync();
+            Assert.NotNull(commandLineApp);
+        }
+
+        [Fact]
+        public async Task UseCommandLineApplicationReThrowsExceptions()
+        {
+            var ex = await Assert.ThrowsAsync<InvalidOperationException>(
+                () => new HostBuilder()
+                    .ConfigureServices(collection => collection.AddSingleton<IConsole>(new TestConsole(_output)))
+                    .UseCommandLineApplication<ThrowsExceptionCommand>(new string[0])
+                    .Build()
+                    .RunCommandLineApplicationAsync());
+            Assert.Equal("A test", ex.Message);
+        }
+
         [Fact]
         public async Task ItThrowsOnUnknownSubCommand()
         {
diff --git a/test/Hosting.CommandLine.Tests/HostBuilderExtensionsBuilderAPITests.cs b/test/Hosting.CommandLine.Tests/HostBuilderExtensionsBuilderAPITests.cs
@@ -108,7 +108,7 @@ public async Task TestUsingServiceProvider()
         public async Task TestCommandLineContextFromNonDIContexts()
         {
             CommandLineContext configureServicesContext = null;
-            CommandLineContext confgureAppContext = null;
+            CommandLineContext configureAppContext = null;
             await new HostBuilder()
                .ConfigureServices((context, collection) =>
                {
@@ -117,14 +117,14 @@ public async Task TestCommandLineContextFromNonDIContexts()
                })
                .ConfigureAppConfiguration((context, builder) =>
                {
-                   confgureAppContext = context.GetCommandLineContext();
+                   configureAppContext = context.GetCommandLineContext();
                })
                .RunCommandLineApplicationAsync(new string[0], app => app.OnExecute(() =>
                {
                }));
 
             Assert.NotNull(configureServicesContext);
-            Assert.NotNull(confgureAppContext);
+            Assert.NotNull(configureAppContext);
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -31,8 +31,7 @@ public async Task ItParsesUsingCustomParserFromConfigAction()`
`31`	`31`	`.ConfigureServices(collection => collection.AddSingleton<IConsole>(new TestConsole(_output)))`
`32`	`32`	`.RunCommandLineApplicationAsync<CustomOptionTypeCommand>(`
`33`	`33`	`new[] { "--custom-type", DemoOptionValue },`
`34`		`- app => app.ValueParsers.AddOrReplace(`
`35`		`- new CustomValueParser()));`
	`34`	`+ app => app.ValueParsers.AddOrReplace(new CustomValueParser()));`
`36`	`35`	`Assert.Equal(0, exitCode);`
`37`	`36`	`}`
`38`	`37`
Original file line number	Diff line number	Diff line change
`@@ -108,7 +108,7 @@ public async Task TestUsingServiceProvider()`
`108`	`108`	`public async Task TestCommandLineContextFromNonDIContexts()`
`109`	`109`	`{`
`110`	`110`	`CommandLineContext configureServicesContext = null;`
`111`		`- CommandLineContext confgureAppContext = null;`
	`111`	`+ CommandLineContext configureAppContext = null;`
`112`	`112`	`await new HostBuilder()`
`113`	`113`	`.ConfigureServices((context, collection) =>`
`114`	`114`	`{`
`@@ -117,14 +117,14 @@ public async Task TestCommandLineContextFromNonDIContexts()`
`117`	`117`	`})`
`118`	`118`	`.ConfigureAppConfiguration((context, builder) =>`
`119`	`119`	`{`
`120`		`- confgureAppContext = context.GetCommandLineContext();`
	`120`	`+ configureAppContext = context.GetCommandLineContext();`
`121`	`121`	`})`
`122`	`122`	`.RunCommandLineApplicationAsync(new string[0], app => app.OnExecute(() =>`
`123`	`123`	`{`
`124`	`124`	`}));`
`125`	`125`
`126`	`126`	`Assert.NotNull(configureServicesContext);`
`127`		`- Assert.NotNull(confgureAppContext);`
	`127`	`+ Assert.NotNull(configureAppContext);`
`128`	`128`	`}`
`129`	`129`	`}`
`130`	`130`	`}`