Merge pull request #1050 from TransactionProcessing/task/#1049_put+post_patch_delete_changes

refactor http methods and add unit tests

Author: StuartFerguson

.github/workflows/pullrequest.yml

@@ -19,7 +19,7 @@ jobs:
     - name: Install NET 9
       uses: actions/[email protected]
       with:
-        dotnet-version: '9.0.x'
+        dotnet-version: '9.0.306'
 
     - name: Restore Nuget Packages
       run: dotnet restore Shared.sln --source ${{ secrets.PUBLICFEEDURL }} --source ${{ secrets.PRIVATEFEED_URL }}
@@ -67,7 +67,7 @@ jobs:
     - name: Install NET 9
       uses: actions/[email protected]
       with:
-        dotnet-version: '9.0.x'
+        dotnet-version: '9.0.306'
 
     - name: Build Windows SQL Server
       run: |

ClientProxyBase/AssemblyInfo.cs

@@ -0,0 +1,3 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Shared.Tests")]

ClientProxyBase/ClientProxyBase.cs

@@ -16,7 +16,7 @@ namespace ClientProxyBase;
 using System.Threading;
 using System.Threading.Tasks;
 
-public abstract class ClientProxyBase {
+public abstract partial class ClientProxyBase {
     #region Fields
 
     /// <summary>
@@ -106,6 +106,7 @@ protected virtual ResponseData<T> HandleResponseContent<T>(String content)
         return JsonConvert.DeserializeObject<ResponseData<T>>(content);
     }
 
+    /*
     protected virtual async Task<Result<TResponse>> SendGetRequest<TResponse>(String uri,
                                                                               String accessToken,
                                                                               CancellationToken cancellationToken) =>
@@ -151,9 +152,9 @@ protected virtual async Task<Result<TResponse>> SendGetRequest<TResponse>(String
         return Result.Success<TResponse>(responseData);
     }
 
-    protected virtual async Task<Result<TResponse>> SendPostRequest<TRequest, TResponse>(String uri, String accessToken, TRequest content, CancellationToken cancellationToken) =>         await this.SendPostRequest<TRequest, TResponse>(uri, accessToken, content, cancellationToken, null);
+    protected virtual async Task<Result<TResponse>> SendPostRequest<TRequest, TResponse>(String uri, String accessToken, TRequest content, CancellationToken cancellationToken) => await this.SendPostRequest<TRequest, TResponse>(uri, accessToken, content, null, cancellationToken);
 
-    protected virtual async Task<Result<TResponse>> SendPostRequest<TRequest, TResponse>(String uri, String accessToken, TRequest content, CancellationToken cancellationToken, List<(String header, String value)> additionalHeaders)
+    protected virtual async Task<Result<TResponse>> SendPostRequest<TRequest, TResponse>(String uri, String accessToken, TRequest content, List<(String header, String value)> additionalHeaders, CancellationToken cancellationToken)
     {
 
         HttpRequestMessage requestMessage = new(HttpMethod.Post, uri);
@@ -184,6 +185,30 @@ protected virtual async Task<Result<TResponse>> SendPostRequest<TRequest, TRespo
         return Result.Success<TResponse>(responseData);
     }
 
+    protected virtual async Task<Result> SendPostRequest<TResponse>(string uri,
+                                                                    string accessToken,
+                                                                    List<(string header, string value)> additionalHeaders,
+                                                                    CancellationToken cancellationToken) {
+        Result result = await this.SendPostRequest<Object>(uri, accessToken, additionalHeaders, cancellationToken);
+        if (result.IsFailed)
+            return ResultHelpers.CreateFailure(result);
+        return Result.Success();
+    }
+
+    protected virtual async Task<Result> SendPostRequest<TResponse>(string uri,
+                                                                    string accessToken,
+                                                                    CancellationToken cancellationToken) =>  await this.SendPostRequest<TResponse>(uri, accessToken, null, cancellationToken);
+
+    //protected virtual async Task<Result> SendPostRequest(string uri,
+    //                                                     string accessToken = null,
+    //                                                     List<(string header, string value)> additionalHeaders = null)
+    //{
+    //    Result<String> result = await SendPostRequest<object, string>(uri, accessToken, null, cancellationToken, additionalHeaders);
+    //    if (result.IsFailed)
+    //        return ResultHelpers.CreateFailure(result);
+    //    return Result.Success();
+    //}
+
     protected virtual async Task<Result<TResponse>> SendPutRequest<TRequest, TResponse>(String uri, String accessToken, TRequest content, CancellationToken cancellationToken) => 
         await this.SendPutRequest<TRequest, TResponse>(uri, accessToken, content, cancellationToken, null);
 
@@ -278,7 +303,7 @@ protected virtual async Task<Result<TResponse>> SendDeleteRequest<TResponse>(Str
         TResponse responseData = JsonConvert.DeserializeObject<TResponse>(result.Data);
 
         return Result.Success<TResponse>(responseData);
-    }
+    }*/
 
     static void AddAdditionalHeaders(HttpRequestMessage requestMessage,
                                      List<(String header, String value)> additionalHeaders) {
@@ -289,7 +314,6 @@ static void AddAdditionalHeaders(HttpRequestMessage requestMessage,
         }
     }
 
-
     #endregion
 }
 

ClientProxyBase/ClientProxyBase_DELETE.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using Shared.Results;
+using SimpleResults;
+
+namespace ClientProxyBase
+{
+    public abstract partial class ClientProxyBase
+    {
+        internal virtual async Task<Result> SendHttpDeleteRequest(String uri,
+                                                                  String accessToken,
+                                                                  List<(String header, String value)> additionalHeaders,
+                                                                  CancellationToken cancellationToken)
+        {
+            HttpRequestMessage requestMessage = new(HttpMethod.Delete, uri);
+            if (String.IsNullOrEmpty(accessToken) == false)
+                requestMessage.Headers.Authorization = new AuthenticationHeaderValue(AuthenticationSchemes.Bearer, accessToken);
+
+            AddAdditionalHeaders(requestMessage, additionalHeaders);
+
+            // Make the Http Call here
+            HttpResponseMessage httpResponse = await this.HttpClient.SendAsync(requestMessage, cancellationToken);
+
+            // Process the response
+            Result<String> result = await this.HandleResponseX(httpResponse, cancellationToken);
+
+            if (result.IsFailed)
+                return ResultHelpers.CreateFailure(result);
+
+            return Result.Success();
+        }
+
+        internal virtual async Task<Result> SendHttpDeleteRequest(String uri,
+                                                                  String accessToken,
+                                                                  CancellationToken cancellationToken) =>
+            await this.SendHttpDeleteRequest(uri, accessToken,null, cancellationToken);
+
+        internal virtual async Task<Result> SendHttpDeleteRequest(String uri,
+                                                                  List<(String header, String value)> additionalHeaders,
+                                                                  CancellationToken cancellationToken) =>
+            await this.SendHttpDeleteRequest(uri, null, additionalHeaders, cancellationToken);
+
+        internal virtual async Task<Result> SendHttpDeleteRequest(String uri,
+                                                                  CancellationToken cancellationToken) =>
+            await this.SendHttpDeleteRequest(uri, null, null, cancellationToken);
+    }
+}

ClientProxyBase/ClientProxyBase_GET.cs

@@ -0,0 +1,56 @@
+using Newtonsoft.Json;
+using Shared.Results;
+using SimpleResults;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ClientProxyBase
+{
+    public abstract partial class ClientProxyBase
+    {
+        internal virtual async Task<Result<TResponse>> SendHttpGetRequest<TResponse>(String uri,
+                                                           String accessToken,
+                                                           List<(String header, String value)> additionalHeaders,
+                                                           CancellationToken cancellationToken)
+        {
+            HttpRequestMessage requestMessage = new(HttpMethod.Get, uri);
+            if (String.IsNullOrEmpty(accessToken) == false)
+                requestMessage.Headers.Authorization = new AuthenticationHeaderValue(AuthenticationSchemes.Bearer, accessToken);
+
+            AddAdditionalHeaders(requestMessage, additionalHeaders);
+
+            // Make the Http Call here
+            HttpResponseMessage httpResponse = await this.HttpClient.SendAsync(requestMessage, cancellationToken);
+
+            // Process the response
+            Result<String> result = await this.HandleResponseX(httpResponse, cancellationToken);
+
+            if (result.IsFailed)
+                return ResultHelpers.CreateFailure(result);
+
+            TResponse responseData = JsonConvert.DeserializeObject<TResponse>(result.Data);
+
+            return Result.Success(responseData);
+        }
+
+        internal virtual async Task<Result<TResponse>> SendHttpGetRequest<TResponse>(String uri,
+                                                                                     String accessToken,
+                                                                                     CancellationToken cancellationToken) =>
+            await this.SendHttpGetRequest<TResponse>(uri, accessToken, null, cancellationToken);
+
+        internal virtual async Task<Result<TResponse>> SendHttpGetRequest<TResponse>(String uri,
+                                                                                     List<(String header, String value)> additionalHeaders,
+                                                                                     CancellationToken cancellationToken) =>
+            await this.SendHttpGetRequest<TResponse>(uri, null, additionalHeaders, cancellationToken);
+
+        internal virtual async Task<Result<TResponse>> SendHttpGetRequest<TResponse>(String uri,
+                                                                                     CancellationToken cancellationToken) =>
+            await this.SendHttpGetRequest<TResponse>(uri, null, null, cancellationToken);
+    }
+}

ClientProxyBase/ClientProxyBase_PATCH.cs

@@ -0,0 +1,69 @@
+using Newtonsoft.Json;
+using Shared.Results;
+using SimpleResults;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ClientProxyBase
+{
+    public abstract partial class ClientProxyBase
+    {
+        internal virtual async Task<Result<TRequest>> SendHttpPatchRequest<TRequest>(String uri,
+                                                                                    TRequest request,
+                                                                                    String accessToken,
+                                                                                    List<(String header, String value)> additionalHeaders,
+                                                                                    CancellationToken cancellationToken)
+        {
+            HttpRequestMessage requestMessage = new(HttpMethod.Patch, uri);
+            if (String.IsNullOrEmpty(accessToken) == false)
+                requestMessage.Headers.Authorization = new AuthenticationHeaderValue(AuthenticationSchemes.Bearer, accessToken);
+
+            AddAdditionalHeaders(requestMessage, additionalHeaders);
+
+            if (request.GetType() == typeof(FormUrlEncodedContent))
+            {
+                // Treat this specially
+                requestMessage.Content = request as FormUrlEncodedContent;
+            }
+            else
+            {
+                requestMessage.Content = new StringContent(JsonConvert.SerializeObject(request), Encoding.UTF8, "application/json");
+            }
+
+            // Make the Http Call here
+            HttpResponseMessage httpResponse = await this.HttpClient.SendAsync(requestMessage, cancellationToken);
+
+            // Process the response
+            Result<String> result = await this.HandleResponseX(httpResponse, cancellationToken);
+
+            if (result.IsFailed)
+                return ResultHelpers.CreateFailure(result);
+
+            return Result.Success();
+        }
+
+        internal virtual async Task<Result<TRequest>> SendHttpPatchRequest<TRequest>(String uri,
+                                                                                      TRequest request,
+                                                                                      String accessToken,
+                                                                                      CancellationToken cancellationToken) =>
+            await this.SendHttpPatchRequest(uri, request, accessToken, null, cancellationToken);
+
+        internal virtual async Task<Result<TRequest>> SendHttpPatchRequest<TRequest>(String uri,
+                                                                                      TRequest request,
+                                                                                      List<(String header, String value)> additionalHeaders,
+                                                                                      CancellationToken cancellationToken) =>
+            await this.SendHttpPatchRequest(uri, request, null, additionalHeaders, cancellationToken);
+
+        internal virtual async Task<Result<TRequest>> SendHttpPatchRequest<TRequest>(String uri,
+                                                                                      TRequest request,
+                                                                                      CancellationToken cancellationToken) =>
+            await this.SendHttpPatchRequest(uri, request, null, null, cancellationToken);
+
+    }
+}