Add `RegularTestControllerClientProxy_AbpRemoteCallException_Tests`

framework/src/Volo.Abp.ExceptionHandling/Volo/Abp/AspNetCore/ExceptionHandling/DefaultExceptionToErrorInfoConverter.cs

@@ -59,9 +59,9 @@ namespace Volo.Abp.AspNetCore.ExceptionHandling
 
             exception = TryToGetActualException(exception);
 
-            if (exception is AbpRemoteCallException remoteCallException)
+            if (exception is AbpRemoteCallException remoteCallException && remoteCallException.Error != null)
             {
-                return remoteCallException.Error ?? new RemoteServiceErrorInfo(remoteCallException.Message);
+                return remoteCallException.Error;
             }
 
             if (exception is AbpDbConcurrencyException)
@@ -76,7 +76,7 @@ namespace Volo.Abp.AspNetCore.ExceptionHandling
 
             var errorInfo = new RemoteServiceErrorInfo();
 
-            if (exception is IUserFriendlyException)
+            if (exception is IUserFriendlyException || exception is AbpRemoteCallException)
             {
                 errorInfo.Message = exception.Message;
                 errorInfo.Details = (exception as IHasErrorDetails)?.Details;

framework/src/Volo.Abp.ExceptionHandling/Volo/Abp/Http/Client/AbpRemoteCallException.cs

@@ -33,8 +33,8 @@ namespace Volo.Abp.Http.Client
 
         }
 
-        public AbpRemoteCallException(RemoteServiceErrorInfo error)
-            : base(error.Message)
+        public AbpRemoteCallException(RemoteServiceErrorInfo error, Exception innerException = null)
+            : base(error.Message, innerException)
         {
             Error = error;
 

framework/src/Volo.Abp.Http.Client/Volo/Abp/Http/Client/ClientProxying/ClientProxyBase.cs

@@ -6,6 +6,8 @@ using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
 using Microsoft.Extensions.Options;
 using Microsoft.Extensions.Primitives;
 using Volo.Abp.Content;
@@ -26,6 +28,7 @@ namespace Volo.Abp.Http.Client.ClientProxying
     {
         public IAbpLazyServiceProvider LazyServiceProvider { get; set; }
 
+        protected ILogger<ClientProxyBase<TService>> Logger => LazyServiceProvider.LazyGetService<ILogger<ClientProxyBase<TService>>>(NullLogger<ClientProxyBase<TService>>.Instance);
         protected IClientProxyApiDescriptionFinder ClientProxyApiDescriptionFinder => LazyServiceProvider.LazyGetRequiredService<IClientProxyApiDescriptionFinder>();
         protected ICancellationTokenProvider CancellationTokenProvider => LazyServiceProvider.LazyGetRequiredService<ICancellationTokenProvider>();
         protected ICorrelationIdProvider CorrelationIdProvider => LazyServiceProvider.LazyGetRequiredService<ICorrelationIdProvider>();
@@ -137,8 +140,7 @@ namespace Volo.Abp.Http.Client.ClientProxying
             {
                 response = await client.SendAsync(
                     requestMessage,
-                    HttpCompletionOption
-                        .ResponseHeadersRead /*this will buffer only the headers, the content will be used as a stream*/,
+                    HttpCompletionOption.ResponseHeadersRead /*this will buffer only the headers, the content will be used as a stream*/,
                     GetCancellationToken(requestContext.Arguments)
                 );
             }
@@ -206,26 +208,46 @@ namespace Volo.Abp.Http.Client.ClientProxying
         {
             if (response.Headers.Contains(AbpHttpConsts.AbpErrorFormat))
             {
-                var errorResponse = JsonSerializer.Deserialize<RemoteServiceErrorResponse>(
-                    await response.Content.ReadAsStringAsync()
-                );
+                RemoteServiceErrorResponse errorResponse;
+                try
+                {
+                    errorResponse = JsonSerializer.Deserialize<RemoteServiceErrorResponse>(
+                        await response.Content.ReadAsStringAsync()
+                    );
+                }
+                catch (Exception ex)
+                {
+                    throw new AbpRemoteCallException(
+                        new RemoteServiceErrorInfo
+                        {
+                            Message = response.ReasonPhrase,
+                            Code = response.StatusCode.ToString()
+                        },
+                        ex
+                    )
+                    {
+                        HttpStatusCode = (int)response.StatusCode
+                    };
+                }
 
                 throw new AbpRemoteCallException(errorResponse.Error)
                 {
                     HttpStatusCode = (int) response.StatusCode
                 };
             }
-
-            throw new AbpRemoteCallException(
-                new RemoteServiceErrorInfo
-                {
-                    Message = response.ReasonPhrase,
-                    Code = response.StatusCode.ToString()
-                }
-            )
+            else
             {
-                HttpStatusCode = (int) response.StatusCode
-            };
+                throw new AbpRemoteCallException(
+                    new RemoteServiceErrorInfo
+                    {
+                        Message = response.ReasonPhrase,
+                        Code = response.StatusCode.ToString()
+                    }
+                )
+                {
+                    HttpStatusCode = (int) response.StatusCode
+                };
+            }
         }
 
         protected virtual void AddHeaders(

framework/test/Volo.Abp.Http.Client.Tests/Volo/Abp/Http/DynamicProxying/RegularTestControllerClientProxy_AbpRemoteCallException_Tests.cs

@@ -0,0 +1,61 @@
+using System.Net.Http;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.Extensions.Hosting;
+using Shouldly;
+using Volo.Abp.AspNetCore.TestBase;
+using Volo.Abp.Http.Client;
+using Volo.Abp.Http.Client.Proxying;
+using Xunit;
+
+namespace Volo.Abp.Http.DynamicProxying
+{
+    public class RegularTestControllerClientProxy_AbpRemoteCallException_Tests : AbpHttpClientTestBase
+    {
+        private readonly IRegularTestController _controller;
+
+        public RegularTestControllerClientProxy_AbpRemoteCallException_Tests()
+        {
+            _controller = ServiceProvider.GetRequiredService<IRegularTestController>();
+        }
+
+        protected override void ConfigureServices(HostBuilderContext context, IServiceCollection services)
+        {
+            services.Replace(ServiceDescriptor.Singleton<IProxyHttpClientFactory, TestProxyHttpClientFactory>());
+        }
+
+        [Fact]
+        public async Task AbpRemoteCallException_On_SendAsync_Test()
+        {
+            var exception = await Assert.ThrowsAsync<AbpRemoteCallException>(async () => await _controller.AbortRequestAsync(default));
+            exception.Message.ShouldContain("An error occurred during the ABP remote HTTP request.");
+        }
+
+        class TestProxyHttpClientFactory : IProxyHttpClientFactory
+        {
+            private readonly ITestServerAccessor _testServerAccessor;
+
+            private int _count;
+
+            public TestProxyHttpClientFactory(ITestServerAccessor testServerAccessor)
+            {
+                _testServerAccessor = testServerAccessor;
+            }
+
+            public HttpClient Create(string name) => Create();
+
+            public HttpClient Create()
+            {
+                if (_count++ > 0)
+                {
+                    //Will get an error on the SendAsync method.
+                    return new HttpClient();
+                }
+
+                // for DynamicHttpProxyInterceptor.GetActionApiDescriptionModel
+                return _testServerAccessor.Server.CreateClient();
+            }
+        }
+    }
+}

framework/test/Volo.Abp.Http.Client.Tests/Volo/Abp/Http/DynamicProxying/RegularTestControllerClientProxy_Tests.cs

@@ -168,8 +168,8 @@ namespace Volo.Abp.Http.DynamicProxying
             var result = await _controller.AbortRequestAsync(default);
             result.ShouldBe("AbortRequestAsync");
 
-            var exception = await Assert.ThrowsAsync<HttpRequestException>(async () => await _controller.AbortRequestAsync(cts.Token));
-            exception.InnerException.InnerException.Message.ShouldBe("The client aborted the request.");
+            var exception = await Assert.ThrowsAsync<AbpRemoteCallException>(async () => await _controller.AbortRequestAsync(cts.Token));
+            exception.InnerException.InnerException.InnerException.Message.ShouldBe("The client aborted the request.");
         }
     }
 }