Switch to MS http client factory in Dibix.Testing

Author: C0nquistadore

src/Dibix.Sdk.CodeGeneration/Output/ApiClientImplementationWriter.cs

@@ -28,8 +28,10 @@ protected override void WriteController(CodeGenerationContext context, CSharpSta
             string interfaceName = $"I{className}";
             CSharpAnnotation interfaceDescriptor = new CSharpAnnotation("HttpService", new CSharpValue($"typeof({interfaceName})"));
             CSharpClass @class = output.AddClass(className, CSharpModifiers.Public | CSharpModifiers.Sealed, interfaceDescriptor)
-                                       .Implements(interfaceName)
-                                       .AddField("BaseAddress", nameof(Uri), new CSharpValue($"new {nameof(Uri)}(\"{context.Model.BaseUrl.TrimEnd('/')}/\")"), CSharpModifiers.Private | CSharpModifiers.Static | CSharpModifiers.ReadOnly);
+                                       .Implements(interfaceName);
+
+            if (!context.Model.UseMicrosoftHttpClient)
+                @class.AddField("BaseAddress", nameof(Uri), new CSharpValue($"new {nameof(Uri)}(\"{context.Model.BaseUrl.TrimEnd('/')}/\")"), CSharpModifiers.Private | CSharpModifiers.Static | CSharpModifiers.ReadOnly);
 
             bool hasBodyParameter = controller.Actions.Any(x => x.RequestBody != null);
             bool requiresAuthorization = controller.Actions.Any(x => x.SecuritySchemes.HasEffectiveRequirements);

src/Dibix.Testing/Dibix.Testing.csproj

@@ -29,6 +29,7 @@
     <PackageReference Include="Microsoft.Extensions.Configuration.EnvironmentVariables" />
     <PackageReference Include="Microsoft.Extensions.Configuration.Json" />
     <PackageReference Include="Microsoft.Extensions.Configuration.UserSecrets" />
+    <PackageReference Include="Microsoft.Extensions.Http" />
     <PackageReference Include="MSTest.TestFramework" />
     <PackageReference Include="System.Diagnostics.EventLog" />
   </ItemGroup>

src/Dibix.Testing/Http/HttpClientFactoryBuilder.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Net.Http;
+using Dibix.Http.Client;
+using Microsoft.Extensions.DependencyInjection;
+using IHttpClientBuilder = Microsoft.Extensions.DependencyInjection.IHttpClientBuilder;
+using IHttpClientFactory = System.Net.Http.IHttpClientFactory;
+
+namespace Dibix.Testing.Http
+{
+    internal abstract class HttpClientFactoryBuilder
+    {
+        private Action<IHttpClientBuilder> _configure;
+
+        protected abstract string ClientName { get; }
+
+        public HttpClientFactoryBuilder Configure(Action<IHttpClientBuilder> configure)
+        {
+            _configure = configure;
+            return this;
+        }
+
+        public IHttpClientFactory Build()
+        {
+            IServiceCollection services = new ServiceCollection();
+
+            IHttpClientBuilder httpClientBuilder = services.AddHttpClient(ClientName, Configure);
+            ConfigureHttpClientDefaults(httpClientBuilder);
+            Configure(httpClientBuilder);
+            _configure?.Invoke(httpClientBuilder);
+
+            ServiceProvider serviceProvider = services.BuildServiceProvider();
+            IHttpClientFactory httpClientFactory = serviceProvider.GetRequiredService<IHttpClientFactory>();
+            return httpClientFactory;
+        }
+
+        protected virtual void Configure(IHttpClientBuilder builder) { }
+
+        protected virtual void Configure(HttpClient client) { }
+
+        private static void ConfigureHttpClientDefaults(IHttpClientBuilder httpClientBuilder)
+        {
+            AddHttpMessageHandler<FollowRedirectHttpMessageHandler>(httpClientBuilder);
+            AddHttpMessageHandler<TraceProxyHttpMessageHandler>(httpClientBuilder);
+            AddHttpMessageHandler<EnsureSuccessStatusCodeHttpMessageHandler>(httpClientBuilder);
+        }
+
+        private static void AddHttpMessageHandler<T>(IHttpClientBuilder httpClientBuilder) where T : DelegatingHandler, new()
+        {
+            httpClientBuilder.AddHttpMessageHandler(() => new T());
+        }
+    }
+}

src/Dibix.Testing/Http/HttpServiceFactory.cs

@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Reflection;
 using Dibix.Http.Client;
+using IHttpClientFactory = System.Net.Http.IHttpClientFactory;
 
 namespace Dibix.Testing.Http
 {
@@ -20,7 +21,7 @@ public static TService CreateServiceInstance<TService>(IHttpClientFactory httpCl
 
         private static TService CreateServiceInstance<TService>(params KeyValuePair<Type, object>[] args)
         {
-            ICollection<KeyValuePair<Type, object>> normalizedArgs = args.Concat(EnumerableExtensions.Create(new KeyValuePair<Type, object>(typeof(string), TestHttpClientConfiguration.HttpClientName))).ToArray();
+            ICollection<KeyValuePair<Type, object>> normalizedArgs = args.Concat(EnumerableExtensions.Create(new KeyValuePair<Type, object>(typeof(string), TestHttpClientFactoryBuilder.HttpClientName))).ToArray();
             Type contractType = typeof(TService);
             Type implementationType = ResolveImplementationType(contractType);
             Type[] constructorSignature = normalizedArgs.Select(x => x.Key).ToArray();

src/Dibix.Testing/Http/HttpTestContext.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Net.Http;
 using Dibix.Http.Client;
+using IHttpClientFactory = System.Net.Http.IHttpClientFactory;
 
 namespace Dibix.Testing.Http
 {
@@ -10,7 +11,7 @@ public class HttpTestContext<TService> : HttpTestContext where TService : IHttpS
 
         public HttpTestContext(TService service, IHttpClientFactory httpClientFactory, IHttpAuthorizationProvider httpAuthorizationProvider) : base(httpClientFactory, httpAuthorizationProvider)
         {
-            this.Service = service;
+            Service = service;
         }
     }
 
@@ -21,13 +22,18 @@ public class HttpTestContext
 
         public HttpTestContext(IHttpClientFactory httpClientFactory, IHttpAuthorizationProvider httpAuthorizationProvider)
         {
-            this.HttpClientFactory = httpClientFactory;
-            this.HttpAuthorizationProvider = httpAuthorizationProvider;
+            HttpClientFactory = httpClientFactory;
+            HttpAuthorizationProvider = httpAuthorizationProvider;
         }
 
-        public TService CreateService<TService>() => HttpServiceFactory.CreateServiceInstance<TService>(this.HttpClientFactory, this.HttpAuthorizationProvider);
+        public TService CreateService<TService>() => HttpServiceFactory.CreateServiceInstance<TService>(HttpClientFactory, HttpAuthorizationProvider);
 
-        public HttpClient CreateClient() => this.HttpClientFactory.CreateClient(TestHttpClientConfiguration.HttpClientName);
-        public HttpClient CreateClient(Uri baseAddress) => this.HttpClientFactory.CreateClient(TestHttpClientConfiguration.HttpClientName, baseAddress);
+        public HttpClient CreateClient() => HttpClientFactory.CreateClient(TestHttpClientFactoryBuilder.HttpClientName);
+        public HttpClient CreateClient(Uri baseAddress)
+        {
+            HttpClient client = CreateClient();
+            client.BaseAddress = baseAddress;
+            return client;
+        }
     }
 }

…ting/Http/TestHttpClientConfiguration.cs …ing/Http/TestHttpClientFactoryBuilder.cssrc/Dibix.Testing/Http/TestHttpClientConfiguration.cs renamed to src/Dibix.Testing/Http/TestHttpClientFactoryBuilder.cs src/Dibix.Testing/Http/TestHttpClientConfiguration.cs renamed to src/Dibix.Testing/Http/TestHttpClientFactoryBuilder.cs

@@ -1,41 +1,39 @@
-using System;
-using System.Diagnostics;
+using System.Diagnostics;
 using System.IO;
 using System.Net.Http;
 using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
 using Dibix.Http.Client;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace Dibix.Testing.Http
 {
-    internal sealed class TestHttpClientConfiguration : HttpClientConfiguration
+    internal sealed class TestHttpClientFactoryBuilder : HttpClientFactoryBuilder
     {
         private readonly TestContext _testContext;
         private readonly TextWriter _logger;
-        private readonly Action<IHttpClientBuilder> _additionalClientConfiguration;
 
         public const string HttpClientName = "Dibix.Testing.TestHttpClient";
-        public override string Name => HttpClientName;
+        protected override string ClientName => HttpClientName;
 
-        public TestHttpClientConfiguration(TestContext testContext, TextWriter logger, Action<IHttpClientBuilder> additionalClientConfiguration)
+        private TestHttpClientFactoryBuilder(TestContext testContext, TextWriter logger)
         {
-            this._testContext = testContext;
-            this._logger = logger;
-            this._additionalClientConfiguration = additionalClientConfiguration;
+            _testContext = testContext;
+            _logger = logger;
         }
 
-        public override void Configure(IHttpClientBuilder builder)
+        public static TestHttpClientFactoryBuilder Create(TestContext testContext, TextWriter logger) => new TestHttpClientFactoryBuilder(testContext, logger);
+
+        protected override void Configure(Microsoft.Extensions.DependencyInjection.IHttpClientBuilder builder)
         {
-            this._additionalClientConfiguration(builder);
-            builder.ConfigureClient(this.ConfigureClient);
-            builder.AddHttpMessageHandler(() => new LoggingHttpMessageHandler(this._logger));
+            builder.AddHttpMessageHandler(() => new LoggingHttpMessageHandler(_logger));
         }
 
-        private void ConfigureClient(HttpClient client)
+        protected override void Configure(HttpClient client)
         {
-            Assembly testAssembly = TestImplementationResolver.ResolveTestAssembly(this._testContext);
+            Assembly testAssembly = TestImplementationResolver.ResolveTestAssembly(_testContext);
             client.AddUserAgent(y => y.FromAssembly(testAssembly, productName =>
             {
                 string normalizedProductName = productName.Replace(".", null);
@@ -47,22 +45,22 @@ private sealed class LoggingHttpMessageHandler : DelegatingHandler
         {
             private readonly TextWriter _output;
 
-            public LoggingHttpMessageHandler(TextWriter output) => this._output = output;
+            public LoggingHttpMessageHandler(TextWriter output) => _output = output;
 
             protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
             {
-                await this._output.WriteAsync($"{request.Method} {request.RequestUri}").ConfigureAwait(false);
+                await _output.WriteAsync($"{request.Method} {request.RequestUri}").ConfigureAwait(false);
                 try
                 {
                     Stopwatch sw = Stopwatch.StartNew();
                     HttpResponseMessage response = await base.SendAsync(request, cancellationToken).ConfigureAwait(false);
                     sw.Stop();
-                    await this._output.WriteAsync($" {(int)response.StatusCode} {response.StatusCode} {sw.Elapsed}").ConfigureAwait(false);
+                    await _output.WriteAsync($" {(int)response.StatusCode} {response.StatusCode} {sw.Elapsed}").ConfigureAwait(false);
                     return response;
                 }
                 finally
                 {
-                    await this._output.WriteLineAsync().ConfigureAwait(false);
+                    await _output.WriteLineAsync().ConfigureAwait(false);
                 }
             }
         }

src/Dibix.Testing/Http/WebApiServiceTestBase.cs

@@ -3,6 +3,7 @@
 using System.Threading.Tasks;
 using Dibix.Http.Client;
 using Dibix.Testing.Data;
+using IHttpClientFactory = System.Net.Http.IHttpClientFactory;
 
 namespace Dibix.Testing.Http
 {

src/Dibix.Testing/Http/WebApiTestBase.cs

@@ -8,20 +8,23 @@
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using Newtonsoft.Json.Serialization;
+using IHttpClientBuilder = Microsoft.Extensions.DependencyInjection.IHttpClientBuilder;
+using IHttpClientFactory = System.Net.Http.IHttpClientFactory;
 
 namespace Dibix.Testing.Http
 {
     public abstract class WebApiTestBase<TConfiguration> : DatabaseTestBase<TConfiguration> where TConfiguration : DatabaseConfigurationBase, new()
     {
         #region Protected Methods
-        protected virtual Task ExecuteTest(Func<HttpTestContext, Task> testFlow) => this.ExecuteTest(testFlow, CreateTestContext);
+        protected virtual Task ExecuteTest(Func<HttpTestContext, Task> testFlow) => ExecuteTest(testFlow, CreateTestContext);
 
         private protected async Task ExecuteTest<TTestContext>(Func<TTestContext, Task> testFlow, Func<IHttpClientFactory, IHttpAuthorizationProvider, TTestContext> contextCreator) where TTestContext : HttpTestContext
         {
-            HttpClientConfiguration clientSetup = new TestHttpClientConfiguration(base.TestContext, base.Out, x => this.ConfigureClient(base.Configuration, x));
-            IHttpClientFactory httpClientFactory = new DefaultHttpClientFactory(clientSetup);
+            IHttpClientFactory httpClientFactory = TestHttpClientFactoryBuilder.Create(TestContext, Out)
+                                                                               .Configure(x => ConfigureClient(Configuration, x))
+                                                                               .Build();
             ITestAuthorizationContext authorizationContext = new TestAuthorizationContext(httpClientFactory);
-            IHttpAuthorizationProvider authorizationProvider = await this.Authorize(authorizationContext, base.Configuration).ConfigureAwait(false);
+            IHttpAuthorizationProvider authorizationProvider = await Authorize(authorizationContext, Configuration).ConfigureAwait(false);
             TTestContext testContext = contextCreator(httpClientFactory, authorizationProvider);
             await testFlow(testContext).ConfigureAwait(false);
         }
@@ -30,7 +33,7 @@ private protected async Task ExecuteTest<TTestContext>(Func<TTestContext, Task>
         protected async Task<TContent> InvokeApi<TService, TContent>(TService service, Expression<Func<TService, Task<HttpResponse<TContent>>>> methodSelector, string expectedText)
         {
             HttpResponse<TContent> response = await InvokeApi(service, methodSelector).ConfigureAwait(false);
-            this.Assert(response, expectedText);
+            Assert(response, expectedText);
             return response.ResponseContent;
         }
         protected Task InvokeApi<TService>(HttpTestContext context, Expression<Func<TService, Task<HttpResponseMessage>>> methodSelector) => InvokeApiCore<TService, HttpResponseMessage>(context, methodSelector);
@@ -42,7 +45,7 @@ protected async Task<TContent> InvokeApi<TService, TContent>(HttpTestContext con
         protected async Task<TContent> InvokeApi<TService, TContent>(HttpTestContext context, Expression<Func<TService, Task<HttpResponse<TContent>>>> methodSelector, string expectedText)
         {
             HttpResponse<TContent> response = await InvokeApiCore(context, methodSelector).ConfigureAwait(false);
-            this.Assert(response, expectedText);
+            Assert(response, expectedText);
             return response.ResponseContent;
         }
 
@@ -82,7 +85,7 @@ private void Assert<TContent>(HttpResponse<TContent> response, string expectedTe
 
                 return value.Value.ToString();
             });
-            base.AssertEqual(expectedTextReplaced, actualText, extension: "json");
+            AssertEqual(expectedTextReplaced, actualText, extension: "json");
         }
 
         private static HttpTestContext CreateTestContext(IHttpClientFactory httpClientFactory, IHttpAuthorizationProvider authorizationProvider)
@@ -96,10 +99,10 @@ private sealed class TestAuthorizationContext : ITestAuthorizationContext
         {
             private readonly IHttpClientFactory _httpClientFactory;
 
-            public TestAuthorizationContext(IHttpClientFactory httpClientFactory) => this._httpClientFactory = httpClientFactory;
+            public TestAuthorizationContext(IHttpClientFactory httpClientFactory) => _httpClientFactory = httpClientFactory;
 
-            public TService CreateService<TService>() => HttpServiceFactory.CreateServiceInstance<TService>(this._httpClientFactory);
-            public TService CreateService<TService>(IHttpAuthorizationProvider authorizationProvider) => HttpServiceFactory.CreateServiceInstance<TService>(this._httpClientFactory, authorizationProvider);
+            public TService CreateService<TService>() => HttpServiceFactory.CreateServiceInstance<TService>(_httpClientFactory);
+            public TService CreateService<TService>(IHttpAuthorizationProvider authorizationProvider) => HttpServiceFactory.CreateServiceInstance<TService>(_httpClientFactory, authorizationProvider);
         }
         #endregion
     }