Remove StatusCode exceptions. Refactoring. (#44)

samples/Arbus.Network.Demo/GetAllOrdersApiEndpoint.cs

@@ -1,6 +1,4 @@
-using Arbus.Network.Abstractions;
-
-namespace Arbus.Network.Demo;
+namespace Arbus.Network.Demo;
 
 public class GetAllOrdersApiEndpoint : ApiEndpoint<OrdersResponseDto>
 {

samples/Arbus.Network.Demo/Program.cs

@@ -1,6 +1,4 @@
-using Arbus.Network.Abstractions;
-using Arbus.Network.Exceptions;
-using Arbus.Network.Implementations;
+using Arbus.Network.Exceptions;
 
 namespace Arbus.Network.Demo;
 

src/Arbus.Network.UnitTests/Tests/NativeHttpClientTests.cs

@@ -1,7 +1,5 @@
-using Arbus.Network.Abstractions;
-using Arbus.Network.Exceptions;
+using Arbus.Network.Exceptions;
 using Arbus.Network.Extensions;
-using Arbus.Network.Implementations;
 
 namespace Arbus.Network.UnitTests.Tests;
 
@@ -32,7 +30,7 @@ public void EnsureNetworkAvailable_NetworkNotAvailable_ThrowsNoNetworkConnection
 
         NativeHttpClient nativeHttpClient = new(mockNetworkManager.Object);
 
-        Assert.Throws<NoNetoworkConnectionException>(() => nativeHttpClient.EnsureNetworkAvailable());
+        Assert.Throws<NoNetworkConnectionException>(() => nativeHttpClient.EnsureNetworkAvailable());
     }
 
     [Test]

src/Arbus.Network/Abstractions/ApiEndpoint.cs → src/Arbus.Network/ApiEndpoint.cs

@@ -3,7 +3,7 @@
 using System.Net.Http.Headers;
 using System.Text;
 
-namespace Arbus.Network.Abstractions;
+namespace Arbus.Network;
 
 public abstract class ApiEndpoint
 {
@@ -71,31 +71,34 @@ public virtual Task ValidateResponse(HttpResponseMessage responseMessage)
     private async Task EnsureSuccessResponse(HttpResponseMessage responseMessage)
     {
         if (responseMessage.IsSuccessStatusCode is false)
-            throw await HandleNotSuccessStatusCode(responseMessage).ConfigureAwait(false);
+            await HandleNotSuccessStatusCode(responseMessage).ConfigureAwait(false);
+
+        //In case of an exception above wil not be thrown make sure to throw an exception
+        responseMessage.EnsureSuccessStatusCode();
     }
 
-    public virtual Task<Exception> HandleNotSuccessStatusCode(HttpResponseMessage responseMessage)
+    public virtual Task HandleNotSuccessStatusCode(HttpResponseMessage responseMessage)
     {
         if (responseMessage.Content.Headers.ContentType?.MediaType == HttpContentType.Application.ProblemJson)
             return HandleProblemDetailsResponse(responseMessage);
         return HandleAnyResponse(responseMessage);
     }
 
-    public static async Task<Exception> HandleProblemDetailsResponse(HttpResponseMessage responseMessage)
+    public static async Task HandleProblemDetailsResponse(HttpResponseMessage responseMessage)
     {
         var responseStream = await responseMessage.Content.ReadAsStreamAsync().ConfigureAwait(false);
 
         var problemDetails = await JsonSerializer.DeserializeAsync<ProblemDetails>(
             responseStream, GlobalJsonSerializerOptions.Options).ConfigureAwait(false)
             ?? throw new Exception("Failed to deserialize ProblemDetails.");
 
-        return NetworkExceptionFactory.Create(responseMessage.StatusCode, problemDetails);
+        throw new NetworkException(responseMessage.StatusCode, problemDetails);
     }
 
-    public virtual async Task<Exception> HandleAnyResponse(HttpResponseMessage responseMessage)
+    public virtual async Task HandleAnyResponse(HttpResponseMessage responseMessage)
     {
         var responseString = await responseMessage.Content.ReadAsStringAsync().ConfigureAwait(false);
-        return NetworkExceptionFactory.Create(responseMessage.StatusCode, responseString);
+        throw new NetworkException(responseMessage.StatusCode, responseString);
     }
 }
 

src/Arbus.Network/Arbus.Network.csproj

@@ -18,11 +18,7 @@
 	</PropertyGroup>
 
 	<ItemGroup>
-		<PackageReference Include="System.Text.Json" Version="7.0.2" />
-	</ItemGroup>
-
-	<ItemGroup Condition=" '$(TargetFramework)' == 'net6.0' ">
-		<Compile Remove="IsExternalInit.cs" />
+		<PackageReference Include="System.Text.Json" Version="7.0.3" />
 	</ItemGroup>
 
 	<ItemGroup>

src/Arbus.Network/Exceptions/NetworkException.cs

@@ -8,17 +8,17 @@ public class NetworkException : Exception
 
     public ProblemDetails? ProblemDetails { get; }
 
-    public NetworkException(HttpStatusCode httpStatusCode, string stringContent) : base(stringContent)
-    {
-        StatusCode = httpStatusCode;
-    }
-
     public NetworkException(HttpStatusCode httpStatusCode, ProblemDetails problemDetails)
         : this(httpStatusCode, problemDetails.Detail ?? problemDetails.Title ?? string.Empty)
     {
         ProblemDetails = problemDetails;
     }
 
+    public NetworkException(HttpStatusCode httpStatusCode, string message) : this(message)
+    {
+        StatusCode = httpStatusCode;
+    }
+
     public NetworkException(string message) : base(message)
     {
     }

src/Arbus.Network/Exceptions/NoNetoworkConnectionException.cs

@@ -1,8 +1,8 @@
 namespace Arbus.Network.Exceptions;
 
-public class NoNetoworkConnectionException : NetworkException
+public class NoNetworkConnectionException : NetworkException
 {
-    public NoNetoworkConnectionException() : base("No network connection.")
+    public NoNetworkConnectionException() : base("No network connection.")
     {
     }
 }

src/Arbus.Network/Extensions/HttpContentExtensions.cs

@@ -3,56 +3,56 @@ namespace Arbus.Network.Extensions;
 public static class HttpContentExtensions
 {
     public static bool IsApplicationJson(this HttpContent content) =>
-        content.IsEqualsTo(HttpContentType.Application.Json);
+        IsRequiredContentType(content, HttpContentType.Application.Json);
 
     public static bool IsApplicationText(this HttpContent content) =>
-        content.IsEqualsTo(HttpContentType.Application.Text);
+        IsRequiredContentType(content, HttpContentType.Application.Text);
 
     public static bool IsApplicationProtobuf(this HttpContent content) =>
-        content.IsEqualsTo(HttpContentType.Application.Protobuf);
+        IsRequiredContentType(content, HttpContentType.Application.Protobuf);
 
     public static bool IsApplicationProblemJson(this HttpContent content) =>
-        content.IsEqualsTo(HttpContentType.Application.ProblemJson);
+        IsRequiredContentType(content, HttpContentType.Application.ProblemJson);
 
     public static bool IsTextPlain(this HttpContent content) =>
-        content.IsEqualsTo(HttpContentType.Text.Plain);
+        IsRequiredContentType(content, HttpContentType.Text.Plain);
 
     public static bool IsMultipartFormData(this HttpContent content) =>
-        content.IsEqualsTo(HttpContentType.Multipart.FormData);
+        IsRequiredContentType(content, HttpContentType.Multipart.FormData);
 
     public static bool IsMultipartMixed(this HttpContent content) =>
-        content.IsEqualsTo(HttpContentType.Multipart.Mixed);
+        IsRequiredContentType(content, HttpContentType.Multipart.Mixed);
 
     public static bool IsMultipartAlternative(this HttpContent content) =>
-        content.IsEqualsTo(HttpContentType.Multipart.Alternative);
+        IsRequiredContentType(content, HttpContentType.Multipart.Alternative);
 
     public static bool IsMultipartRelated(this HttpContent content) =>
-        content.IsEqualsTo(HttpContentType.Multipart.Related);
+        IsRequiredContentType(content, HttpContentType.Multipart.Related);
 
     public static bool IsImageSvgXml(this HttpContent content) =>
-        content.IsEqualsTo(HttpContentType.Image.SvgXml);
+        IsRequiredContentType(content, HttpContentType.Image.SvgXml);
 
     public static bool IsImageGif(this HttpContent content) =>
-        content.IsEqualsTo(HttpContentType.Image.Gif);
+        IsRequiredContentType(content, HttpContentType.Image.Gif);
 
     public static bool IsImageJpeg(this HttpContent content) =>
-        content.IsEqualsTo(HttpContentType.Image.Jpeg);
+        IsRequiredContentType(content, HttpContentType.Image.Jpeg);
 
     public static bool IsImagePng(this HttpContent content) =>
-        content.IsEqualsTo(HttpContentType.Image.Png);
+        IsRequiredContentType(content, HttpContentType.Image.Png);
 
     public static bool IsImageTiff(this HttpContent content) =>
-        content.IsEqualsTo(HttpContentType.Image.Tiff);
+        IsRequiredContentType(content, HttpContentType.Image.Tiff);
 
     public static bool IsImageVndMicrosoftIcon(this HttpContent content) =>
-        content.IsEqualsTo(HttpContentType.Image.VndMicrosoftIcon);
+        IsRequiredContentType(content, HttpContentType.Image.VndMicrosoftIcon);
 
     public static bool IsImageXIcon(this HttpContent content) =>
-        content.IsEqualsTo(HttpContentType.Image.XIcon);
+        IsRequiredContentType(content, HttpContentType.Image.XIcon);
 
     public static bool IsImageVndDjvu(this HttpContent content) =>
-        content.IsEqualsTo(HttpContentType.Image.VndDjvu);
+        IsRequiredContentType(content, HttpContentType.Image.VndDjvu);
 
-    private static bool IsEqualsTo(this HttpContent content, string contentType) =>
-        content.Headers.ContentType.MediaType == contentType;
+    private static bool IsRequiredContentType(HttpContent content, string contentType) =>
+        content.Headers.ContentType?.MediaType == contentType;
 }

src/Arbus.Network/HttpClientContext.cs

@@ -0,0 +1,50 @@
+using System.Net.Http.Headers;
+
+namespace Arbus.Network;
+
+public class HttpClientContext : IHttpClientContext
+{
+    protected INativeHttpClient _nativeHttpClient;
+
+    public HttpClientContext(INativeHttpClient httpClientHandler)
+    {
+        _nativeHttpClient = httpClientHandler;
+    }
+
+    public async Task RunEndpoint(ApiEndpoint endpoint)
+    {
+        using var responseMessage = await RunEndpointInternal(endpoint).ConfigureAwait(false);
+    }
+
+    public async Task<TResponse> RunEndpoint<TResponse>(ApiEndpoint<TResponse> endpoint)
+    {
+        using var responseMessage = await RunEndpointInternal(endpoint).ConfigureAwait(false);
+        return await endpoint.GetResponse(responseMessage).ConfigureAwait(false);
+    }
+
+    public virtual async Task<HttpResponseMessage> RunEndpointInternal(ApiEndpoint endpoint)
+    {
+        var request = CreateRequest(endpoint);
+
+        var response = await _nativeHttpClient.SendRequest(
+            request, endpoint.CancellationToken ?? default).ConfigureAwait(false);
+
+        await endpoint.ValidateResponse(response).ConfigureAwait(false);
+
+        return response;
+    }
+
+    private HttpRequestMessage CreateRequest(ApiEndpoint endpoint)
+    {
+        var request = endpoint.CreateRequest(
+            GetBaseUri());
+        AddHeaders(request.Headers);
+        return request;
+    }
+
+    public virtual Uri? GetBaseUri() => default;
+
+    protected virtual void AddHeaders(HttpRequestHeaders headers)
+    {
+    }
+}

src/Arbus.Network/IHttpContext.cs

@@ -0,0 +1,7 @@
+namespace Arbus.Network;
+
+public interface IHttpClientContext
+{
+    Task RunEndpoint(ApiEndpoint endpoint);
+    Task<TResponse> RunEndpoint<TResponse>(ApiEndpoint<TResponse> endpoint);
+}

src/Arbus.Network/Abstractions/INativeHttpClient.cs → src/Arbus.Network/INativeHttpClient.cs

@@ -1,4 +1,4 @@
-namespace Arbus.Network.Abstractions;
+namespace Arbus.Network;
 
 public interface INativeHttpClient
 {

src/Arbus.Network/INetworkManager.cs

@@ -0,0 +1,7 @@
+namespace Arbus.Network;
+
+public interface INetworkManager
+{
+    bool IsNetworkAvailable { get; }
+    event EventHandler<bool>? NetworkAvailabilityChanged;
+}